@remnic/core 9.63.6 → 9.63.8

package/dist/chunk-PRDJMOST.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-state.ts"],"sourcesContent":["import { appendFile, mkdir, readFile, rename, rm, stat, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { log } from \"./logger.js\";\nimport { writeFileAtomically } from \"./maintenance/atomic-file.js\";\nimport { isErrnoCode } from \"./utils/errno.js\";\nimport { withHeldFileLock, type HeldFileLockOptions } from \"./utils/serialize-mutations.js\";\nimport { ensureContainedSpillDir, listContainedSpillFiles } from \"./utils/path-containment.js\";\nimport type { SearchDegradation } from \"./search/port.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  includedMemoryIds?: string[];\n  includedMemoryPaths?: string[];\n  includedMemoryNamespaces?: Array<string | undefined>;\n  omittedMemoryIds?: 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  recallNamespaces?: 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  resultNamespaces?: Array<string | undefined>;\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   * Backend degradations observed while serving this recall (issue #1536).\n   * Present only when a search backend reported unavailable/loading/timeout\n   * during the recall — distinguishing \"no matches\" from \"backend could not\n   * answer\" (CLAUDE.md rule 34). Deliberately independent of `tierExplain`,\n   * which is gated behind `recallDirectAnswerEnabled`.\n   */\n  backendDegradations?: SearchDegradation[];\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  /** Graph-relative activation path node ids when provenance is enabled. */\n  pathNodeIds?: string[];\n  /** True when a graph path penalty was applied. */\n  pathPenaltyApplied?: boolean;\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      if (\n        Array.isArray(item.pathNodeIds) &&\n        item.pathNodeIds.every((value): value is string => typeof value === \"string\")\n      ) {\n        out.pathNodeIds = item.pathNodeIds.slice(0, 64);\n      }\n      if (typeof item.pathPenaltyApplied === \"boolean\") {\n        out.pathPenaltyApplied = item.pathPenaltyApplied;\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>;\ntype StateFileWriter = (filePath: string, content: string) => Promise<void>;\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 */\n/**\n * Stale-snapshot identity guard shared by the annotate methods (issue #518):\n * a writeNonce match wins outright; otherwise traceId (when expected) and\n * recordedAt are compared. Extracted so every annotation surface applies\n * identical guards (CLAUDE.md rule 22).\n */\nfunction snapshotMatchesExpectedIdentity(\n  current: LastRecallSnapshot,\n  expected?: { writeNonce?: string; traceId?: string; recordedAt?: string },\n): boolean {\n  if (!expected) return true;\n  if (typeof expected.writeNonce === \"string\" && expected.writeNonce.length > 0) {\n    return current.writeNonce === expected.writeNonce;\n  }\n  const hasExpectedTraceId =\n    typeof expected.traceId === \"string\" && expected.traceId.length > 0;\n  if (hasExpectedTraceId) {\n    return current.traceId === expected.traceId;\n  }\n  if (expected.recordedAt !== undefined) {\n    return current.recordedAt === expected.recordedAt;\n  }\n  return true;\n}\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\n/**\n * Suffix marking an impression spill CLAIMED for commit but not yet deleted.\n * The crash-safe drain renames `<uuid>.jsonl` -> `<uuid>.jsonl.claimed` before\n * committing its rows, mirroring the lifecycle ledger's claim/commit protocol\n * (#2033).\n */\nconst CLAIMED_IMPRESSION_SPILL_SUFFIX = \".claimed\";\n\n/**\n * Outcome of {@link LastRecallStore.drainPendingImpressions}. Distinguishes a\n * completed drain (or nothing pending) from a DEFERRED drain that left durable\n * spills in the offline-sync-EXCLUDED queue, so the caller can tell the\n * data-safe cases apart from the one where an offline-sync snapshot would\n * silently omit recorded impressions (#2033).\n */\nexport interface DrainPendingImpressionsResult {\n  /** Pending spill rows were folded into the synced active file this call. */\n  folded: boolean;\n  /**\n   * Durable spill rows remain in the offline-sync-EXCLUDED pending queue after\n   * this drain: the rotation lock could not be acquired, a spill could not be\n   * claimed, or the drain-only fold left rows that would only fit by rotating\n   * into a sync-excluded archive. A snapshot taken now would silently omit them\n   * (#2033): the caller MUST treat the active file as INCOMPLETE and retry or\n   * abort the snapshot rather than report success. `false` means the active file\n   * is complete — every pending row was folded or nothing was pending.\n   */\n  pendingDeferred: boolean;\n}\n\nexport class LastRecallStore {\n  private readonly statePath: string;\n  private readonly impressionsPath: string;\n  private readonly writeStateFile: StateFileWriter;\n  private readonly impressionsRotateBytes: number;\n  private readonly impressionsRotateKeep: number;\n  // Lock-acquisition timing for the cross-process impression rotation lock.\n  // Only tests set this (small maxWaitMs) to force the acquisition-timeout\n  // (`acquired=false`) branch deterministically; production uses the defaults.\n  private readonly impressionsLockOptions?: Pick<HeldFileLockOptions, \"maxWaitMs\" | \"pollMs\">;\n  private state: LastRecallState = {};\n  private stateWriteChain: Promise<void> = Promise.resolve();\n  // Serializes the rotate-then-append critical section so concurrent record()\n  // calls never interleave rotation renames with each other's appends (#1910).\n  private impressionsWriteChain: Promise<void> = Promise.resolve();\n\n  constructor(\n    memoryDir: string,\n    options: {\n      writeStateFile?: StateFileWriter;\n      impressionsRotateBytes?: number;\n      impressionsRotateKeep?: number;\n      impressionsLockOptions?: Pick<HeldFileLockOptions, \"maxWaitMs\" | \"pollMs\">;\n    } = {},\n  ) {\n    this.statePath = path.join(memoryDir, \"state\", \"last_recall.json\");\n    this.impressionsPath = path.join(memoryDir, \"state\", \"recall_impressions.jsonl\");\n    // 0 disables rotation (never coerced to a default); keep floors at 1.\n    this.impressionsRotateBytes = Math.max(0, Math.floor(options.impressionsRotateBytes ?? 0));\n    this.impressionsRotateKeep = Math.max(1, Math.floor(options.impressionsRotateKeep ?? 5));\n    this.impressionsLockOptions = options.impressionsLockOptions;\n    this.writeStateFile =\n      options.writeStateFile ??\n      (async (filePath, content) => {\n        await writeFileAtomically(filePath, content);\n      });\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    recallNamespaces?: 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    resultNamespaces?: Array<string | undefined>;\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    /**\n     * Backend degradations observed while serving this recall (issue #1536).\n     * Passed at record time so the published snapshot is born annotated —\n     * a post-record annotation would leave a window where readers see the\n     * snapshot without them (codex review on #1544).\n     */\n    backendDegradations?: SearchDegradation[];\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 and\n    // 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      recallNamespaces: opts.recallNamespaces,\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      resultNamespaces: opts.resultNamespaces,\n      policyVersion: opts.policyVersion,\n      identityInjectionMode: opts.identityInjection?.mode,\n      identityInjectedChars: opts.identityInjection?.injectedChars,\n      identityInjectionTruncated: opts.identityInjection?.truncated,\n      tierExplain: opts.tierExplain,\n      backendDegradations:\n        opts.backendDegradations && opts.backendDegradations.length > 0\n          ? opts.backendDegradations\n          : undefined,\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 this.flushState();\n    } catch (err) {\n      log.debug(`last recall store write failed: ${err}`);\n    }\n\n    if (opts.appendImpression !== false) {\n      const line = JSON.stringify(snapshot) + \"\\n\";\n      // Chain onto the previous impression write so rotation + append run as one\n      // serialized critical section — concurrent record() calls can never\n      // interleave a rename with another call's append (#1910). `.catch` before\n      // the link keeps a prior failure from poisoning the chain.\n      const chained = this.impressionsWriteChain\n        .catch(() => {})\n        .then(() => this.appendImpressionSerialized(line));\n      this.impressionsWriteChain = chained;\n      try {\n        await chained;\n      } catch (err) {\n        log.debug(`recall impressions append failed: ${err}`);\n      }\n    }\n  }\n\n  /**\n   * Drain pending spills, rotate (best-effort, sized to the projected payload),\n   * then append one impression line under ONE shared cross-process lock (#1910,\n   * #2033). Both the archive-shift renames AND the append run inside the same\n   * held lock so a peer process holding the lock can never rename the active\n   * inode to `.1` between our open and write — which would land the impression in\n   * a rotated archive that offline-sync excludes, silently dropping it from\n   * active-state/sync consumers.\n   *\n   * On lock-acquisition timeout the impression is NEVER written to the active\n   * file unlocked (#2033): a peer holding the lock is likely mid-rotation, so an\n   * unlocked append can land in the inode it is about to rename to `.1` — the\n   * exact silent-drop this lock prevents. Instead the row is spilled to a\n   * durable node-local per-event file under `<impressions>.pending.d/` and\n   * folded back into the active file by the next append that DOES hold the lock,\n   * preserving durability without racing rotation. Rotation failure under the\n   * held lock is logged and the append still runs. Callers invoke this only\n   * through `impressionsWriteChain` so the sequence is serialized in-process.\n   */\n  private get impressionsPendingDir(): string {\n    return `${this.impressionsPath}.pending.d`;\n  }\n\n  private async spillImpression(line: string): Promise<void> {\n    await ensureContainedSpillDir(this.impressionsPendingDir);\n    // Write to a temp name the drain's `.jsonl` lister ignores, then atomically\n    // rename to the final `<uuid>.jsonl` (#2033). writeFile creates the path\n    // before its bytes are durable, so writing straight to the final name lets a\n    // concurrent lock holder's drain read/rename/delete a partial spill and\n    // append malformed JSON — permanently losing that impression. The temp lives\n    // in the SAME contained dir, so the rename is atomic and stays symlink-safe.\n    const id = randomUUID();\n    const tempPath = path.join(this.impressionsPendingDir, `${id}.jsonl.tmp`);\n    const finalPath = path.join(this.impressionsPendingDir, `${id}.jsonl`);\n    await writeFile(tempPath, line, \"utf-8\");\n    await rename(tempPath, finalPath);\n  }\n\n  /**\n   * Recover a claim a crashed drain left mid-flight (#2033): the crash-safe\n   * drain renames `<uuid>.jsonl` -> `<uuid>.jsonl.claimed` BEFORE committing, so\n   * a `.claimed` file with no matching commit is the ONLY durable copy of those\n   * rows. Rename each orphan back to `<uuid>.jsonl` so it re-enters the normal\n   * collect+claim+commit flow. MUST run under the held rotation lock, before\n   * collecting. listContainedSpillFiles skips symlinked/escaping entries.\n   */\n  private async recoverOrphanedImpressionClaims(): Promise<void> {\n    const orphans = await listContainedSpillFiles(\n      this.impressionsPendingDir,\n      `.jsonl${CLAIMED_IMPRESSION_SPILL_SUFFIX}`,\n    );\n    for (const claimedPath of orphans) {\n      const original = claimedPath.slice(0, -CLAIMED_IMPRESSION_SPILL_SUFFIX.length);\n      await rename(claimedPath, original).catch(() => undefined);\n    }\n  }\n\n  /**\n   * Recover a crash-orphaned spill temp after its write completed but before\n   * the atomic `.tmp` → `.jsonl` rename. Valid JSONL temps are promoted back\n   * into the normal queue; incomplete temps remain pending and keep offline sync\n   * deferred rather than being discarded.\n   */\n  private async recoverOrphanedImpressionTemps(): Promise<void> {\n    const temps = await listContainedSpillFiles(this.impressionsPendingDir, \".jsonl.tmp\");\n    for (const tempPath of temps) {\n      let content: string;\n      try {\n        content = await readFile(tempPath, \"utf-8\");\n        for (const line of content.split(\"\\n\")) {\n          if (line.trim().length > 0) JSON.parse(line);\n        }\n      } catch {\n        continue;\n      }\n      const finalPath = tempPath.slice(0, -\".tmp\".length);\n      await rename(tempPath, finalPath).catch(() => undefined);\n    }\n  }\n\n  private async appendImpressionSerialized(line: string): Promise<void> {\n    await mkdir(path.dirname(this.impressionsPath), { recursive: true });\n    // Every active-file write goes under the shared cross-process rotation lock,\n    // even when THIS writer's local rotation is disabled (`impressionsRotateBytes\n    // <= 0`). A peer process with rotation enabled shares this lock and may\n    // rename the active inode to `.1` at any moment, so an unlocked append could\n    // land in an offline-sync-excluded archive and be silently dropped (#2033).\n    // Only the local rotate DECISION is disabled — the bounded fold skips\n    // rotation when this writer's limit is 0 — the lock itself is not.\n    const lockPath = `${this.impressionsPath}.lock`;\n    await withHeldFileLock(\n      lockPath,\n      { staleMs: 30_000, ...this.impressionsLockOptions },\n      async (acquired) => {\n        // withHeldFileLock falls back to task(false) when it cannot acquire the\n        // lock within the budget. Do NOT append to the active file unlocked: a\n        // peer holding the lock may be mid-rotation, so an unlocked append could\n        // land in the inode it renames to `.1` (an offline-sync-excluded\n        // archive), silently dropping the impression. Spill it to the durable\n        // pending queue instead — the next lock holder folds it back in (#2033).\n        if (!acquired) {\n          log.debug(\"recall impressions rotation lock not acquired; spilling impression to the durable pending queue\");\n          await this.spillImpression(line);\n          return;\n        }\n        await this.foldPendingImpressionsAndAppend(line);\n      },\n    );\n  }\n\n  /**\n   * Fold any durable pending recall-impression spills into the synced active\n   * `recall_impressions.jsonl` WITHOUT recording a new impression (#2033).\n   *\n   * The pending spill dir is offline-sync-excluded, so an impression that a\n   * lock-timed-out `record()` spilled there is absent from an offline-sync\n   * snapshot and lost if this node is discarded before the next `record()`\n   * folds it back. Offline sync calls this before building a snapshot so a\n   * recorded impression always reaches the remote. Fast no-op — no lock and no\n   * dir/lock-file creation — when nothing is pending.\n   *\n   * Returns a {@link DrainPendingImpressionsResult}: `folded` is true when rows\n   * were folded into the active file; `pendingDeferred` is true when durable\n   * spills still remain in the offline-sync-EXCLUDED queue after this call —\n   * because the rotation lock could not be acquired, a spill could not be\n   * claimed, or the drain-only fold deferred rows that would only fit by\n   * rotating into a sync-excluded archive (#2033). A snapshot taken while\n   * `pendingDeferred` is true would silently drop those rows, so the caller MUST\n   * NOT report a clean snapshot — it either retries or aborts.\n   */\n  async drainPendingImpressions(): Promise<DrainPendingImpressionsResult> {\n    if (!(await this.pendingSpillsRemain())) {\n      return { folded: false, pendingDeferred: false };\n    }\n    const lockPath = `${this.impressionsPath}.lock`;\n    let folded = false;\n    let acquiredLock = false;\n    let spillsRemain = false;\n    await withHeldFileLock(\n      lockPath,\n      { staleMs: 30_000, ...this.impressionsLockOptions },\n      async (acquired) => {\n        // A peer holds the lock (mid-rotation or mid-append). We MUST NOT touch\n        // the active file unlocked (#2033), so the spills stay in the\n        // offline-sync-EXCLUDED pending queue. Report the drain as DEFERRED\n        // (pendingDeferred=true) so the caller does not build a snapshot that\n        // silently omits them; the next lock holder — or a caller retry — folds\n        // them in.\n        if (!acquired) return;\n        acquiredLock = true;\n        folded = await this.foldPendingImpressionsAndAppend(null);\n        // Even WITH the lock, a spill the fold could not claim or a `.claimed`\n        // orphan a failed commit left behind keeps durable rows in the excluded\n        // queue. Treat that as an incomplete drain so the caller retries/aborts\n        // rather than snapshotting an active file that omits them (#2033).\n        spillsRemain = await this.pendingSpillsRemain();\n      },\n    );\n    return { folded, pendingDeferred: !acquiredLock || spillsRemain };\n  }\n\n  /**\n   * Claim/commit fold of durable pending impression spills into the active file\n   * under the held rotation lock (#2033). `line` is a new impression to append\n   * after the drained rows, or null for a drain-only pre-sync fold.\n   *\n   * Each spill is folded as an INDEPENDENT claim -> append -> finalize unit\n   * rather than materializing the whole queue as one joined payload and\n   * splitting it in a single synchronous pass (#2033). A multi-hundred-MB drain\n   * done as one join/split blocks the event loop long enough for\n   * `withHeldFileLock`'s ownership-refresh timer to miss its window, so a peer\n   * stale-breaks the 30s lock and rotates/appends concurrently — defeating the\n   * rotation lock this drain relies on. The per-file `await`s keep the payload\n   * bounded to one spill at a time and let the refresh timer fire between files.\n   *\n   * The DRAIN-ONLY path (`line === null`, run before an offline-sync snapshot)\n   * NEVER rotates a drained row into an archive. `recall_impressions.jsonl.*`\n   * is offline-sync-EXCLUDED, so rotating a just-drained row into `.1`/`.2` and\n   * then deleting its spill would leave that row only in a path sync omits —\n   * silently lost when the node is discarded after a \"successful\" sync (#2033).\n   * It folds only the rows that fit the synced active file under the cap and\n   * leaves the rest durable in the pending queue; {@link drainPendingImpressions}\n   * then reports the drain DEFERRED so the caller retries or aborts. The\n   * record() path (`line !== null`) keeps rotating normally — its archives stay\n   * on a live node that is not being discarded.\n   *\n   * Recovers any crash-orphaned claim first. Each impression carries a unique\n   * writeNonce, so a crash-recovered re-commit is a collapsible duplicate, never\n   * a lost row. listContainedSpillFiles rejects symlinked/escaping entries; a\n   * spill that cannot be claimed is skipped this pass. An append failure rolls\n   * that spill's claim back so the row retries on the next lock holder's drain.\n   * Returns true when the active file was written. MUST run under the held\n   * rotation lock.\n   */\n  private async foldPendingImpressionsAndAppend(line: string | null): Promise<boolean> {\n    await this.recoverOrphanedImpressionTemps();\n    await this.recoverOrphanedImpressionClaims();\n    const spillFiles = await listContainedSpillFiles(this.impressionsPendingDir);\n    const drainOnly = line === null;\n    const cap = this.impressionsRotateBytes;\n    let activeSize = 0;\n    if (cap > 0) {\n      try {\n        activeSize = (await stat(this.impressionsPath)).size;\n      } catch (err) {\n        if (!isErrnoCode(err, \"ENOENT\")) throw err;\n      }\n    }\n    let wrote = false;\n    for (const filePath of spillFiles) {\n      const content = await readFile(filePath, \"utf-8\");\n      const unit = content.length === 0 || content.endsWith(\"\\n\") ? content : `${content}\\n`;\n      const unitBytes = Buffer.byteLength(unit, \"utf-8\");\n      // Drain-only fold must never push a drained row into a sync-excluded\n      // archive (#2033). Once the active file cannot take this spill under the\n      // cap without rotating, stop: the remaining spills stay durable in the\n      // pending queue and the drain reports itself deferred. A lone spill larger\n      // than the cap on an empty active file is still folded whole (it cannot be\n      // split without corrupting JSONL) so it reaches sync rather than stranding.\n      if (drainOnly && cap > 0 && activeSize > 0 && activeSize + unitBytes >= cap) break;\n      const claimedPath = `${filePath}${CLAIMED_IMPRESSION_SPILL_SUFFIX}`;\n      try {\n        await rename(filePath, claimedPath);\n      } catch {\n        continue; // could not claim → do not commit; a later drain retries it.\n      }\n      try {\n        activeSize = await this.appendImpressionUnit(unit, activeSize, drainOnly);\n      } catch (err) {\n        // Commit failed: roll this spill's claim back so it retries on the next\n        // lock holder's drain instead of being lost.\n        await rename(claimedPath, filePath).catch(() => undefined);\n        throw err;\n      }\n      // Commit is durable: delete the claimed file. A delete that fails leaves a\n      // `.claimed` orphan the next drain recovers and re-commits — a\n      // writeNonce-collapsible duplicate, never a lost row (#2033).\n      await unlink(claimedPath).catch(() => undefined);\n      wrote = true;\n    }\n    if (line !== null) {\n      activeSize = await this.appendImpressionUnit(line, activeSize, false);\n      wrote = true;\n    }\n    return wrote;\n  }\n\n  /**\n   * Append one whole JSONL unit (a claimed spill's rows or a fresh impression\n   * line) to the active impressions file, returning the resulting active-file\n   * byte size. On the rotating (record) path, when the unit would push the\n   * current active generation to/over `impressionsRotateBytes`, the full active\n   * file is rotated aside FIRST so no generation exceeds the cap (#2033); a lone\n   * unit larger than the cap on an empty active file is written whole because\n   * splitting a JSONL row would corrupt it. `drainOnly` and disabled rotation\n   * (`impressionsRotateBytes <= 0`) both skip rotation — drain-only defers its\n   * overflow in {@link foldPendingImpressionsAndAppend} rather than rotating into\n   * a sync-excluded archive. A rotation error is logged and the append still\n   * runs so a row is never lost; an append failure propagates so the caller\n   * rolls its claim back. MUST run under the held rotation lock.\n   */\n  private async appendImpressionUnit(\n    unit: string,\n    activeSize: number,\n    drainOnly: boolean,\n  ): Promise<number> {\n    const cap = this.impressionsRotateBytes;\n    const unitBytes = Buffer.byteLength(unit, \"utf-8\");\n    if (cap > 0 && !drainOnly && activeSize > 0 && activeSize + unitBytes >= cap) {\n      try {\n        await this.shiftImpressionArchives();\n        activeSize = 0;\n      } catch (err) {\n        log.debug(`recall impressions rotation failed (append preserved): ${err}`);\n      }\n    }\n    await appendFile(this.impressionsPath, unit, \"utf-8\");\n    return activeSize + unitBytes;\n  }\n\n  /**\n   * True when any live `<uuid>.jsonl` spill, crash-orphaned `.claimed` file,\n   * or crash-orphaned `.jsonl.tmp` spill remains in the offline-sync-EXCLUDED\n   * pending queue (#2033). After a drain acquires the rotation lock, a spill\n   * the fold could not claim (rename race / read-only dir) or a `.claimed`\n   * orphan a failed commit left behind means durable rows are STILL excluded\n   * from a snapshot — the drain must report itself INCOMPLETE so the caller\n   * retries or aborts rather than snapshotting an active file that omits them.\n   */\n  private async pendingSpillsRemain(): Promise<boolean> {\n    if ((await listContainedSpillFiles(this.impressionsPendingDir, \".jsonl.tmp\")).length > 0) {\n      return true;\n    }\n    const liveSpills = await listContainedSpillFiles(this.impressionsPendingDir);\n    if (liveSpills.length > 0) return true;\n    const claimed = await listContainedSpillFiles(\n      this.impressionsPendingDir,\n      `.jsonl${CLAIMED_IMPRESSION_SPILL_SUFFIX}`,\n    );\n    return claimed.length > 0;\n  }\n\n  /**\n   * Shift `.1..N` archives down one slot and move the active file to `.1`,\n   * dropping anything beyond `keep`. Callers invoke this only while holding the\n   * cross-process rotation lock (issue #1910).\n   */\n  private async shiftImpressionArchives(): Promise<void> {\n    const keep = this.impressionsRotateKeep;\n    // Drop the archive that would fall off the end, then shift down: .(keep-1)\n    // -> .keep, ..., .1 -> .2, active -> .1.\n    try {\n      await rm(`${this.impressionsPath}.${keep}`, { force: true });\n    } catch {\n      // best-effort cleanup of the oldest archive\n    }\n    for (let i = keep - 1; i >= 1; i -= 1) {\n      try {\n        await rename(`${this.impressionsPath}.${i}`, `${this.impressionsPath}.${i + 1}`);\n      } catch (err) {\n        if (!isErrnoCode(err, \"ENOENT\")) throw err;\n      }\n    }\n    try {\n      await rename(this.impressionsPath, `${this.impressionsPath}.1`);\n    } catch (err) {\n      if (!isErrnoCode(err, \"ENOENT\")) throw err;\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 (!snapshotMatchesExpectedIdentity(current, expected)) return;\n    this.state[sessionKey] = {\n      ...current,\n      tierExplain: cloneTierExplain(tierExplain),\n    };\n    try {\n      await this.flushState();\n    } catch (err) {\n      log.debug(`last recall tier-explain annotate failed: ${err}`);\n    }\n  }\n\n\n  private flushState(): Promise<void> {\n    const run = this.stateWriteChain.catch(() => undefined).then(async () => {\n      await mkdir(path.dirname(this.statePath), { recursive: true });\n      await this.writeStateFile(this.statePath, JSON.stringify(this.state, null, 2));\n    });\n    this.stateWriteChain = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    return run;\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\n\n/**\n * Per-session bounded history of recent recall memory-id sets, used ONLY by\n * handle resolution (issue #1582). Distinct from {@link LastRecallStore} —\n * that keeps ONE last snapshot per session; this keeps a small ring (depth N)\n * of the memory-id arrays a session has recalled, newest first, so a handle\n * cited in a later turn still resolves even after a newer recall displaced the\n * \"last\" snapshot.\n *\n * Deliberately lightweight: stores only `string[]` per entry (no full\n * snapshot), capped at `depth` per session and 50 sessions total (rule 27\n * slice/cap guards). Misses are acceptable and tagged at resolution time.\n */\nexport class RecallHandleHistoryStore {\n  private readonly statePath: string;\n  private readonly writeStateFile: StateFileWriter;\n  private state: Record<string, Array<{ at: string; ids: string[] }>> = {};\n  private writeChain: Promise<void> = Promise.resolve();\n  private readonly maxDepth: number;\n\n  constructor(memoryDir: string, options: { writeStateFile?: StateFileWriter; maxDepth?: number } = {}) {\n    this.statePath = path.join(memoryDir, \"state\", \"handle_history.json\");\n    this.writeStateFile =\n      options.writeStateFile ??\n      (async (filePath, content) => {\n        await writeFileAtomically(filePath, content);\n      });\n    this.maxDepth =\n      typeof options.maxDepth === \"number\" && Number.isFinite(options.maxDepth)\n        ? Math.max(1, Math.min(50, Math.floor(options.maxDepth)))\n        : 5;\n  }\n\n  async load(): Promise<void> {\n    try {\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw);\n      if (parsed && typeof parsed === \"object\") this.state = parsed as typeof this.state;\n    } catch {\n      this.state = {};\n    }\n  }\n\n  /**\n   * Record one recall's admitted memory ids for a session, newest first.\n   * The ring is capped at {@link maxDepth}; older entries drop off the tail.\n   */\n  async record(sessionKey: string, memoryIds: readonly string[]): Promise<void> {\n    if (!sessionKey) return;\n    const ids = memoryIds.filter((id): id is string => typeof id === \"string\" && id.length > 0);\n    const entry = { at: new Date().toISOString(), ids };\n    const prior = this.state[sessionKey] ?? [];\n    const next = [entry, ...prior].slice(0, this.maxDepth);\n    this.state[sessionKey] = next;\n    this.capSessions();\n    try {\n      await this.flush();\n    } catch (err) {\n      log.debug(`recall handle history write failed: ${err}`);\n    }\n  }\n\n  /**\n   * Return the memory-id arrays for a session, newest first, capped at `depth`.\n   * Empty array when the session has no recorded history.\n   */\n  recent(sessionKey: string, depth: number = this.maxDepth): Array<readonly string[]> {\n    const entries = this.state[sessionKey];\n    if (!entries || entries.length === 0) return [];\n    const limit = Math.max(0, Math.min(depth, entries.length));\n    return entries.slice(0, limit).map((e) => e.ids);\n  }\n\n  /** Test seam: drop all history (used by the corpus-scan hygiene test). */\n  clearForTest(): void {\n    this.state = {};\n  }\n\n  private capSessions(): void {\n    const keys = Object.keys(this.state);\n    if (keys.length <= 50) return;\n    const ordered = keys\n      .map((k) => ({ k, at: this.state[k]?.[0]?.at ?? \"\" }))\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  private flush(): Promise<void> {\n    const run = this.writeChain.catch(() => undefined).then(async () => {\n      await mkdir(path.dirname(this.statePath), { recursive: true });\n      await this.writeStateFile(this.statePath, JSON.stringify(this.state, null, 2));\n    });\n    this.writeChain = run.then(() => undefined, () => undefined);\n    return run;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-R7TZ2HCS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/extraction-prompt.ts"],"sourcesContent":["/**\n * Extraction prompt construction (issue #1995 sibling extraction).\n *\n * The system prompt, its JSON response shape, and the placeholder table\n * derived from that shape are prompt DATA, not engine behavior. They live here\n * so `extraction.ts` holds the pipeline and one module owns the text every\n * extraction path — local LLM, direct client, gateway fallback — sends.\n */\n\nimport { AMBIENT_CAPTURE_PROMPT_SECTION, AMBIENT_SPECULATIVE_TIER_CLAUSE } from \"./ambient-provenance.js\";\nimport { resolveMemoryLifecycleCapabilities, resolveRecallAuxiliaryCapabilities } from \"./capabilities.js\";\nimport type { PluginConfig } from \"./types.js\";\n\nexport const EXTRACTION_RESPONSE_SHAPE = `{\n  \"facts\": [{\n    \"category\": \"<category>\",\n    \"content\": \"<source-grounded statement>\",\n    \"confidence\": 0.0,\n    \"tags\": [\"<tag>\"],\n    \"entityRef\": \"<optional normalized-name>\",\n    \"cueAnchors\": [{\"type\": \"<anchor-type>\", \"value\": \"<entity-or-topic plus key aspect>\"}],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"quote\": \"<optional exact contiguous source span>\",\n    \"scope\": \"<optional project-or-global>\",\n    \"structuredAttributes\": {\"<key>\": \"<value>\"},\n    \"procedureSteps\": [{\"order\": 1, \"intent\": \"<step>\"}, {\"order\": 2, \"intent\": \"<step>\"}],\n    \"reasoningTrace\": {\n      \"steps\": [{\"order\": 1, \"description\": \"<step>\"}, {\"order\": 2, \"description\": \"<step>\"}],\n      \"finalAnswer\": \"<answer>\",\n      \"observedOutcome\": \"<optional outcome>\"\n    },\n    \"eventTime\": \"<optional source temporal expression>\"\n  }],\n  \"entities\": [{\n    \"name\": \"<normalized-name>\",\n    \"type\": \"<entity-type>\",\n    \"facts\": [\"<source-grounded statement>\"],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"structuredSections\": [{\"key\": \"<section-key>\", \"title\": \"<section-title>\", \"facts\": [\"<source-grounded statement>\"]}]\n  }],\n  \"profileUpdates\": [\"<source-grounded profile update>\"],\n  \"questions\": [{\"question\": \"<source-grounded unresolved question>\", \"context\": \"<source-grounded context>\", \"priority\": 0.0}],\n  \"identityReflection\": \"<conversation-grounded agent reflection>\",\n  \"episodeTitle\": \"<six-to-eight word conversation segment title>\",\n  \"relationships\": [{\"source\": \"<normalized-name>\", \"target\": \"<normalized-name>\", \"label\": \"<source-grounded relationship>\"}]\n}`;\nexport const EXTRACTION_RESPONSE_PLACEHOLDERS: Record<string, true> = {};\nfor (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\\r\\n]+>/g) ?? []) {\n  EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;\n}\nexport const CUE_ANCHOR_PROMPT_INSTRUCTION = `- For each fact, emit at most 3 \"cueAnchors\".\n- Each cue anchor value must be a source-grounded search hook of at most 120 characters, in the form \"<main entity or topic> <key aspect>\".\n- Set each cue anchor type to entity, file, tool, outcome, constraint, or date.\n- Omit cue anchors when the conversation does not support a useful search hook.\n- Example: \"Alice booked Bistro Max for Mike's surprise party\" can use {\"type\":\"entity\",\"value\":\"Mike surprise party\"} and {\"type\":\"entity\",\"value\":\"Alice restaurant booking\"}.`;\n\n/**\n * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on\n * every extraction entry path when `temporal.biTemporal` is on so the LLM\n * emits an optional per-fact `eventTime` expression. The expression is\n * resolved against the source turn timestamp at write time — never\n * wall-clock — so replay/import of old transcripts anchors correctly.\n * Returns an empty string when the gate is off (byte-identical prompt).\n */\nexport function eventTimePromptInstruction(config: PluginConfig): string {\n  if (!config.temporalBiTemporal) return \"\";\n  return `\nWhen a fact states when it became or stopped being true, copy that explicit temporal expression verbatim into \"eventTime\". Omit \"eventTime\" when no such expression appears; never infer dates.`;\n}\n\n/**\n * Build extraction instructions shared between local and cloud LLM.\n *\n * `ambientCapture` marks input from an always-on recorder, which may carry\n * speech the user never authored (issue #2294).\n */\nexport function buildExtractionInstructions(\n  config: PluginConfig,\n  existingEntities?: string[],\n  ambientCapture = false\n): string {\n  const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);\n  return `You are a memory extraction system. Analyze the following conversation and extract durable, reusable memories.\n\nMemory categories:\n- fact: Objective information about the world\n- preference: User likes, dislikes, or stylistic choices\n- correction: User correcting a mistake or misconception (highest priority)\n- entity: Information about a specific person, project, tool, or company\n- decision: A choice that was made with rationale\n- relationship: How two entities relate to each other (e.g., \"Alice is Bob's manager\", \"Acme Corp uses Shopify\")\n- principle: Durable rules, values, or operating beliefs (e.g., \"never use Chat Completions API\")\n- commitment: Promises, obligations, or deadlines (e.g., \"deploy by Friday\", \"call accountant Monday\")\n- moment: Emotionally significant events or milestones (e.g., \"first successful deployment of engram\")\n- skill: Capabilities the user or agent has demonstrated (e.g., \"user is proficient with Kubernetes\")${\n    resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction\n      ? `\n- rule: Causal rules discovered through experience (format: \"IF <condition> THEN <action/outcome>\", e.g., \"IF Shopify API returns 401 THEN the admin token is missing read_products scope\")`\n      : \"\"\n  }\n- procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to \"procedure\". Use \"content\" for a short title that includes explicit trigger phrasing (e.g. \"When you deploy to production…\", \"Whenever you ship a release…\"). Add \"procedureSteps\": an array of at least two objects {\"order\": number, \"intent\": \"concrete step description\"} in execution order. Optional per-step \"toolCall\": {\"kind\": \"…\", \"signature\": \"…\"}, \"expectedOutcome\", \"optional\": true.\n- reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. \"Here's how I debugged the latency spike: first I checked…, then I…, finally I…\"). Set category to \"reasoning_trace\". Use \"content\" for a short title summarising the problem (e.g. \"How I debugged the staging latency spike\"). Add \"reasoningTrace\": {\"steps\": [{\"order\": number, \"description\": \"what happened at this step\"}, …], \"finalAnswer\": \"the conclusion or answer\", \"observedOutcome\": \"optional confirmation of how it played out\"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning — not for ordinary decisions (use \"decision\") or reusable workflows (use \"procedure\").\n\nRules:\n- Only extract genuinely new information worth remembering across sessions.\n- Statements must be grounded in the conversation.\n- Do not treat instruction text, schema placeholders, or examples as conversation evidence.\n- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.\n- Skip transient task details and operational noise, including routine scheduler, monitoring, or automation status.\n- Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? \" > rules\" : \"\"} > preferences > commitments > decisions > relationships > entities > moments > skills > facts\n- Corrections get highest confidence.\n- Each fact should be a standalone, self-contained statement.\n- Entity references should use normalized names (lowercase, hyphenated: \"jane-doe\", \"acme-corp\")\n- CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: \"acme-corp\" NOT \"acmecorp\" or \"acme\". \"jane-doe\" NOT \"janedoe\" or \"jane\". If unsure, prefer the most specific full name.\n- Avoid creating entities typed as \"other\" when a more specific type fits (company, project, tool, person, place)\n${CUE_ANCHOR_PROMPT_INSTRUCTION}\n- When entity facts clearly belong under a durable named heading, add them to entity.structuredSections as {key, title, facts}. Example person headings: \"Beliefs\", \"Communication Style\", \"Building / Working On\". Leave structuredSections empty when no stable heading fits.\n- Tags should be concise and reusable (e.g., \"coding-style\", \"personal\", \"tools\")\n- When a fact contains measurable, categorical, or precisely valued data, include a \"structuredAttributes\" field with key-value string pairs (e.g., {\"price\": \"29.99\", \"brand\": \"Sony\"}, {\"date\": \"2024-03-15\", \"location\": \"SF\"}, {\"chosen\": \"PostgreSQL\", \"rejected\": \"MongoDB\"}). Only for concrete values, not narrative content.\n- Set confidence using these tiers:\n  * Explicit (0.95-1.0): Direct user statements — \"I prefer X\", \"my name is Y\"\n  * Implied (0.70-0.94): Strong contextual inference — user consistently does X, clear from conversation flow\n  * Inferred (0.40-0.69): Pattern recognition — reasonable guess from limited evidence\n  * Speculative (0.00-0.39): Tentative hypothesis — weak signal, needs future confirmation. Speculative memories auto-expire after 30 days if not confirmed.${ambientCapture ? AMBIENT_SPECULATIVE_TIER_CLAUSE : \"\"}${\n    config.provenance?.enabled\n      ? `\n- Source quotes: For each fact, include a \"quote\" field containing the EXACT verbatim words from the conversation that support the fact. Copy a contiguous span from a single speaker turn (not a paraphrase, not a summary). Cap at ~300 characters. This grounds every memory in the literal utterance that created it.`\n      : \"\"\n  }\n- For commitments: include any deadline or timeframe mentioned${\n    lifecycleCaps.extractionScopeClassification\n      ? `\n\nScope classification:\nFor each fact, set \"scope\" to one of:\n- \"global\" — knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), general coding patterns, infrastructure knowledge, technology facts not tied to one codebase\n- \"project\" — knowledge specific to one codebase: file paths, environment configs, deployment details, project-specific workarounds, team/stakeholder info tied to one project, repo-specific conventions. Tool, command, or CLI-flag instructions TIED TO ONE AGENT are also \"project\", because the same tool name means different things in different agent integrations (a \"search\" tool may search repository code in one agent and the web in another); when keeping such an agent-tied instruction, the fact text MUST name the originating agent as a leading \"In <agent>,\" clause (e.g. \"In Pi, use the search tool with a repository path.\"). A tool/command fact that holds in every agent and every repo is NOT agent-tied — leave it \"global\" and do not add a qualifier (e.g. \"\\`git status --short\\` emits compact output\"). Examples: \"In Pi, the search tool takes a repository path\" -> \"project\"; \"\\`git status --short\\` emits compact output\" -> \"global\".\nWhen in doubt, prefer \"project\" — it is safer to keep knowledge scoped narrowly.`\n      : \"\"\n  }\n${\n  ambientCapture\n    ? `${AMBIENT_CAPTURE_PROMPT_SECTION}\n`\n    : \"\"\n}\nEntity creation rules (STRICT):\n- Only create entities for DURABLE things: real people, companies, products, tools, ongoing projects\n- NEVER create entities for transient items: individual PRs, branches, Jira tickets, meetings, agent task IDs, log files, database tables, cron job runs, sessions\n- When you learn something about a transient item (e.g., PR #58 fixed a bug), store it as a FACT with an entityRef to the parent project — do NOT create an entity for the PR itself\n- Prefer attaching facts to broad parent entities rather than creating sub-entities. E.g., \"acme-store uses Algolia for search\" is a fact on entity \"acme-store\", NOT a new entity \"acme-store-algolia-connector\"\n- The entity list should be SHORT — think \"things that would have their own Wikipedia page\" not \"things mentioned in passing\"\n\n${\n  existingEntities && existingEntities.length > 0\n    ? `\nKNOWN ENTITIES (use these exact names when referencing existing things):\n${existingEntities.join(\", \")}\n\nWhen you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.\n`\n    : \"\"\n}\n${eventTimePromptInstruction(config)}\nAlso extract relationships between entities mentioned in the conversation.\n- Format: {source: \"entity-name\", target: \"entity-name\", label: \"relationship description\"}\n- Max 5 relationships per extraction\n- Only include clear, durable relationships (e.g., \"works at\", \"created\", \"manages\", \"uses\")\n- Use normalized entity names (e.g., \"person-jane-doe\", \"company-acme-corp\")\n\n\nAlso emit \"episodeTitle\" as a six-to-eight word title for this conversation segment.\nQuestions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.\n\nFinally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;\n}\n"],"mappings":";;;;;;;;;;AAaO,IAAM,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiClC,IAAM,mCAAyD,CAAC;AACvE,WAAW,eAAe,0BAA0B,MAAM,eAAe,KAAK,CAAC,GAAG;AAChF,mCAAiC,WAAW,IAAI;AAClD;AACO,IAAM,gCAAgC;AAAA;AAAA;AAAA;AAAA;AActC,SAAS,2BAA2B,QAA8B;AACvE,MAAI,CAAC,OAAO,mBAAoB,QAAO;AACvC,SAAO;AAAA;AAET;AAQO,SAAS,4BACd,QACA,kBACA,iBAAiB,OACT;AACR,QAAM,gBAAgB,mCAAmC,MAAM;AAC/D,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uGAaL,mCAAmC,MAAM,EAAE,uBACvC;AAAA,+LAEA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sCAUoC,mCAAmC,MAAM,EAAE,uBAAuB,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrH,6BAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mKAQ+H,iBAAiB,kCAAkC,EAAE,GAC/M,OAAO,YAAY,UACf;AAAA,6TAEA,EACN;AAAA,gEAEE,cAAc,gCACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yFAOA,EACN;AAAA,EAEA,iBACI,GAAG,8BAA8B;AAAA,IAEjC,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASE,oBAAoB,iBAAiB,SAAS,IAC1C;AAAA;AAAA,EAEJ,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,IAIvB,EACN;AAAA,EACE,2BAA2B,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYpC;","names":[]}