@illuma-ai/agents 1.1.25 → 1.3.0

package/dist/cjs/memory/paths.cjs

@@ -0,0 +1,217 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+
+/**
+ * Autonomous memory — canonical path whitelist + tier utilities.
+ *
+ * Single source of truth for the 8 stable memory documents. Every write
+ * goes through {@link assertWritablePath}; every reader can ask
+ * {@link getTierForPath} what a row belongs to. Adding or removing a
+ * path means editing this file — and exactly this file.
+ *
+ * ## Why a whitelist?
+ *
+ * Earlier upstream-faithful designs used date-keyed files
+ * (`memory/YYYY-MM-DD.md`), which have three problems for a persistent
+ * multi-user agent:
+ *
+ * 1. **Unbounded growth** — one row per day per agent per user, forever.
+ * 2. **LLM routing ambiguity** — "which date file do I read?" has no
+ *    good answer, so the model reads (and ranks against) all of them.
+ * 3. **No natural deduplication** — the same fact written across three
+ *    days returns three near-identical hits.
+ *
+ * With 8 stable canonical documents the LLM knows *exactly* where to
+ * write ("is this a preference? → `memory/user/preferences.md`") and
+ * each row accumulates via UPSERT instead of piling up new rows.
+ *
+ * ## Two tiers
+ *
+ * - **Agent tier** (`memory/agent/*`) — operational knowledge that
+ *   every caller of the agent benefits from. Stored with `user_id = NULL`.
+ *   Shared across all users of a collaborative agent; the only tier that
+ *   exists for isolated/autonomous agents with no invoker.
+ *
+ * - **User tier** (`memory/user/*`) — per-invoker personalization.
+ *   Stored with `user_id = <caller>`. Read path filters so User A never
+ *   sees User B's rows, even for the same agent. Not writable unless the
+ *   flush scope carries a non-empty `userId`.
+ *
+ * The tier of a path is a function of its prefix (`memory/agent/` vs
+ * `memory/user/`), so adding a new document is one line here + the
+ * constant array entry; no store or route code has to change.
+ */
+/** Agent-tier documents — shared across all users of the agent. */
+const MEMORY_AGENT_PATHS = Object.freeze([
+    Object.freeze({
+        path: 'memory/agent/playbook.md',
+        tier: 'agent',
+        label: 'Playbook',
+        description: 'Successful task patterns and workflows that have worked for this agent — ' +
+            'reusable recipes, known-good tool sequences, approaches that consistently ' +
+            'produce the right result.',
+    }),
+    Object.freeze({
+        path: 'memory/agent/pitfalls.md',
+        tier: 'agent',
+        label: 'Pitfalls',
+        description: 'Tool failures, error recoveries, schema mistakes, and invalid argument ' +
+            'shapes the agent has seen — so the same mistake is not repeated on future ' +
+            'turns. One note per distinct failure mode.',
+    }),
+    Object.freeze({
+        path: 'memory/agent/domain.md',
+        tier: 'agent',
+        label: 'Domain',
+        description: 'Durable facts about the systems, APIs, data models, and business rules ' +
+            'this agent operates on — things that are true independent of any one user ' +
+            'and that the agent repeatedly needs to know.',
+    }),
+    Object.freeze({
+        path: 'memory/agent/style.md',
+        tier: 'agent',
+        label: 'Style',
+        description: 'Tone, formatting, and response-shape conventions the agent has converged ' +
+            'on across the whole user base. Do NOT write user-specific preferences here ' +
+            '(those belong under the user tier).',
+    }),
+]);
+/** User-tier documents — per-invoker, never shared across users. */
+const MEMORY_USER_PATHS = Object.freeze([
+    Object.freeze({
+        path: 'memory/user/profile.md',
+        tier: 'user',
+        label: 'Profile',
+        description: "This specific user's identity — name, role, team, sign-off name, " +
+            'responsibilities, stable facts about who they are. Only facts ' +
+            'volunteered by the user themselves.',
+    }),
+    Object.freeze({
+        path: 'memory/user/preferences.md',
+        tier: 'user',
+        label: 'Preferences',
+        description: 'How THIS user wants things done — preferred formats, verbosity, tone, ' +
+            'cadence, output length, language conventions. Explicit corrections they ' +
+            'have given count as preferences.',
+    }),
+    Object.freeze({
+        path: 'memory/user/projects.md',
+        tier: 'user',
+        label: 'Projects',
+        description: "This user's current initiatives, ongoing work, deadlines, and active " +
+            'project context. Include dates in the prose when relevant. Retire entries ' +
+            'by overwriting them on future flushes when the user indicates a project is done.',
+    }),
+    Object.freeze({
+        path: 'memory/user/references.md',
+        tier: 'user',
+        label: 'References',
+        description: 'External systems, dashboards, accounts, links, channels, and resources ' +
+            "THIS user has pointed the agent at — the 'where to look' pointers that " +
+            'make later turns more efficient.',
+    }),
+]);
+/** All 8 canonical documents in display order: agent tier first, user tier second. */
+const MEMORY_ALL_PATHS = Object.freeze([
+    ...MEMORY_AGENT_PATHS,
+    ...MEMORY_USER_PATHS,
+]);
+/** Fast O(1) lookup map: path → descriptor. */
+const PATH_INDEX = new Map(MEMORY_ALL_PATHS.map((p) => [p.path, p]));
+/** Set of all whitelisted paths — for `has()` lookups. */
+const MEMORY_WRITABLE_PATHS = new Set(MEMORY_ALL_PATHS.map((p) => p.path));
+/** Returns the descriptor for a canonical path, or `undefined` if not on the whitelist. */
+function getPathDescriptor(path) {
+    return PATH_INDEX.get(path);
+}
+/**
+ * Returns the tier a given path belongs to.
+ *
+ * For unknown paths (e.g. legacy date-keyed rows that predate this schema),
+ * falls back to inspecting the `memory/agent/` or `memory/user/` prefix.
+ * Anything that matches neither is classified as `agent` — it will surface
+ * in the admin UI under the agent-tier header and stay read-only there.
+ */
+function getTierForPath(path) {
+    const descriptor = PATH_INDEX.get(path);
+    if (descriptor)
+        return descriptor.tier;
+    if (path.startsWith('memory/user/'))
+        return 'user';
+    return 'agent';
+}
+/**
+ * Paths that are legal to write **for this caller's scope**.
+ *
+ * If `scope.userId` is absent (isolated/autonomous agent), the user-tier
+ * paths are dropped. This is the list the flush prompt renders into its
+ * rubric — the LLM never sees paths it cannot write to.
+ */
+function getWritablePathsForScope(scope) {
+    if (scope.userId == null || scope.userId === '') {
+        return MEMORY_AGENT_PATHS;
+    }
+    return MEMORY_ALL_PATHS;
+}
+/**
+ * Validates a write path against the whitelist AND the caller's scope.
+ *
+ * Throws with an actionable message when:
+ * - the path is missing the `memory/` prefix
+ * - the path is not on the 8-doc whitelist
+ * - the path is user-tier but `scope.userId` is missing
+ *
+ * The store's append() is the single call site; other callers should
+ * never hit this directly. Kept as a standalone function for testability.
+ */
+function assertWritablePath(path, scope) {
+    if (!path || !path.startsWith(constants.MEMORY_PATH_PREFIX)) {
+        throw new Error(`memory_append path must start with "${constants.MEMORY_PATH_PREFIX}" (received "${path}")`);
+    }
+    const descriptor = PATH_INDEX.get(path);
+    if (!descriptor) {
+        throw new Error(`memory_append path "${path}" is not on the canonical whitelist. ` +
+            `Allowed: ${MEMORY_ALL_PATHS.map((p) => p.path).join(', ')}`);
+    }
+    if (descriptor.tier === 'user' &&
+        (scope.userId == null || scope.userId === '')) {
+        throw new Error(`memory_append to user-tier path "${path}" requires a caller userId in scope, ` +
+            `but scope.userId is missing. This path is private to a specific user and ` +
+            `cannot be written from an isolated/autonomous context.`);
+    }
+    return descriptor;
+}
+/**
+ * Renders the whitelist as a compact bullet list, used inside the flush
+ * prompt so the LLM sees the authoritative rubric at inference time.
+ *
+ * Output shape:
+ *   - memory/agent/playbook.md [Playbook, shared] — <description>
+ *   - memory/agent/pitfalls.md [Pitfalls, shared] — <description>
+ *   ...
+ *
+ * The `[Label, shared|private]` tag tells the model whether the doc is
+ * visible to all users (agent tier) or only to the caller (user tier).
+ * Filtered to only the paths writable for the given scope.
+ */
+function renderPathsRubric(scope) {
+    const writable = getWritablePathsForScope(scope);
+    return writable
+        .map((p) => {
+        const visibility = p.tier === 'agent' ? 'shared' : 'private';
+        return `- ${p.path} [${p.label}, ${visibility}] — ${p.description}`;
+    })
+        .join('\n');
+}
+
+exports.MEMORY_AGENT_PATHS = MEMORY_AGENT_PATHS;
+exports.MEMORY_ALL_PATHS = MEMORY_ALL_PATHS;
+exports.MEMORY_USER_PATHS = MEMORY_USER_PATHS;
+exports.MEMORY_WRITABLE_PATHS = MEMORY_WRITABLE_PATHS;
+exports.assertWritablePath = assertWritablePath;
+exports.getPathDescriptor = getPathDescriptor;
+exports.getTierForPath = getTierForPath;
+exports.getWritablePathsForScope = getWritablePathsForScope;
+exports.renderPathsRubric = renderPathsRubric;
+//# sourceMappingURL=paths.cjs.map

package/dist/cjs/memory/paths.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.cjs","sources":["../../../src/memory/paths.ts"],"sourcesContent":["/**\n * Autonomous memory — canonical path whitelist + tier utilities.\n *\n * Single source of truth for the 8 stable memory documents. Every write\n * goes through {@link assertWritablePath}; every reader can ask\n * {@link getTierForPath} what a row belongs to. Adding or removing a\n * path means editing this file — and exactly this file.\n *\n * ## Why a whitelist?\n *\n * Earlier upstream-faithful designs used date-keyed files\n * (`memory/YYYY-MM-DD.md`), which have three problems for a persistent\n * multi-user agent:\n *\n * 1. **Unbounded growth** — one row per day per agent per user, forever.\n * 2. **LLM routing ambiguity** — \"which date file do I read?\" has no\n *    good answer, so the model reads (and ranks against) all of them.\n * 3. **No natural deduplication** — the same fact written across three\n *    days returns three near-identical hits.\n *\n * With 8 stable canonical documents the LLM knows *exactly* where to\n * write (\"is this a preference? → `memory/user/preferences.md`\") and\n * each row accumulates via UPSERT instead of piling up new rows.\n *\n * ## Two tiers\n *\n * - **Agent tier** (`memory/agent/*`) — operational knowledge that\n *   every caller of the agent benefits from. Stored with `user_id = NULL`.\n *   Shared across all users of a collaborative agent; the only tier that\n *   exists for isolated/autonomous agents with no invoker.\n *\n * - **User tier** (`memory/user/*`) — per-invoker personalization.\n *   Stored with `user_id = <caller>`. Read path filters so User A never\n *   sees User B's rows, even for the same agent. Not writable unless the\n *   flush scope carries a non-empty `userId`.\n *\n * The tier of a path is a function of its prefix (`memory/agent/` vs\n * `memory/user/`), so adding a new document is one line here + the\n * constant array entry; no store or route code has to change.\n */\n\nimport { MEMORY_PATH_PREFIX } from './constants';\nimport type { MemoryScope } from './types';\n\n/** Tier discriminator — the two kinds of memory a row can belong to. */\nexport type MemoryTier = 'agent' | 'user';\n\n/** Every canonical document the flush phase is allowed to write. */\nexport interface MemoryPathDescriptor {\n  /** Full path including the `memory/` prefix. */\n  path: string;\n  /** Which tier the path lives under. */\n  tier: MemoryTier;\n  /** Short label shown in UI tier badges and the flush prompt rubric. */\n  label: string;\n  /** One-line description — fed to the LLM to make routing unambiguous. */\n  description: string;\n}\n\n/** Agent-tier documents — shared across all users of the agent. */\nexport const MEMORY_AGENT_PATHS: readonly MemoryPathDescriptor[] =\n  Object.freeze([\n    Object.freeze({\n      path: 'memory/agent/playbook.md',\n      tier: 'agent' as const,\n      label: 'Playbook',\n      description:\n        'Successful task patterns and workflows that have worked for this agent — ' +\n        'reusable recipes, known-good tool sequences, approaches that consistently ' +\n        'produce the right result.',\n    }),\n    Object.freeze({\n      path: 'memory/agent/pitfalls.md',\n      tier: 'agent' as const,\n      label: 'Pitfalls',\n      description:\n        'Tool failures, error recoveries, schema mistakes, and invalid argument ' +\n        'shapes the agent has seen — so the same mistake is not repeated on future ' +\n        'turns. One note per distinct failure mode.',\n    }),\n    Object.freeze({\n      path: 'memory/agent/domain.md',\n      tier: 'agent' as const,\n      label: 'Domain',\n      description:\n        'Durable facts about the systems, APIs, data models, and business rules ' +\n        'this agent operates on — things that are true independent of any one user ' +\n        'and that the agent repeatedly needs to know.',\n    }),\n    Object.freeze({\n      path: 'memory/agent/style.md',\n      tier: 'agent' as const,\n      label: 'Style',\n      description:\n        'Tone, formatting, and response-shape conventions the agent has converged ' +\n        'on across the whole user base. Do NOT write user-specific preferences here ' +\n        '(those belong under the user tier).',\n    }),\n  ]);\n\n/** User-tier documents — per-invoker, never shared across users. */\nexport const MEMORY_USER_PATHS: readonly MemoryPathDescriptor[] = Object.freeze(\n  [\n    Object.freeze({\n      path: 'memory/user/profile.md',\n      tier: 'user' as const,\n      label: 'Profile',\n      description:\n        \"This specific user's identity — name, role, team, sign-off name, \" +\n        'responsibilities, stable facts about who they are. Only facts ' +\n        'volunteered by the user themselves.',\n    }),\n    Object.freeze({\n      path: 'memory/user/preferences.md',\n      tier: 'user' as const,\n      label: 'Preferences',\n      description:\n        'How THIS user wants things done — preferred formats, verbosity, tone, ' +\n        'cadence, output length, language conventions. Explicit corrections they ' +\n        'have given count as preferences.',\n    }),\n    Object.freeze({\n      path: 'memory/user/projects.md',\n      tier: 'user' as const,\n      label: 'Projects',\n      description:\n        \"This user's current initiatives, ongoing work, deadlines, and active \" +\n        'project context. Include dates in the prose when relevant. Retire entries ' +\n        'by overwriting them on future flushes when the user indicates a project is done.',\n    }),\n    Object.freeze({\n      path: 'memory/user/references.md',\n      tier: 'user' as const,\n      label: 'References',\n      description:\n        'External systems, dashboards, accounts, links, channels, and resources ' +\n        \"THIS user has pointed the agent at — the 'where to look' pointers that \" +\n        'make later turns more efficient.',\n    }),\n  ]\n);\n\n/** All 8 canonical documents in display order: agent tier first, user tier second. */\nexport const MEMORY_ALL_PATHS: readonly MemoryPathDescriptor[] = Object.freeze([\n  ...MEMORY_AGENT_PATHS,\n  ...MEMORY_USER_PATHS,\n]);\n\n/** Fast O(1) lookup map: path → descriptor. */\nconst PATH_INDEX: ReadonlyMap<string, MemoryPathDescriptor> = new Map(\n  MEMORY_ALL_PATHS.map((p) => [p.path, p])\n);\n\n/** Set of all whitelisted paths — for `has()` lookups. */\nexport const MEMORY_WRITABLE_PATHS: ReadonlySet<string> = new Set(\n  MEMORY_ALL_PATHS.map((p) => p.path)\n);\n\n/** Returns the descriptor for a canonical path, or `undefined` if not on the whitelist. */\nexport function getPathDescriptor(\n  path: string\n): MemoryPathDescriptor | undefined {\n  return PATH_INDEX.get(path);\n}\n\n/**\n * Returns the tier a given path belongs to.\n *\n * For unknown paths (e.g. legacy date-keyed rows that predate this schema),\n * falls back to inspecting the `memory/agent/` or `memory/user/` prefix.\n * Anything that matches neither is classified as `agent` — it will surface\n * in the admin UI under the agent-tier header and stay read-only there.\n */\nexport function getTierForPath(path: string): MemoryTier {\n  const descriptor = PATH_INDEX.get(path);\n  if (descriptor) return descriptor.tier;\n  if (path.startsWith('memory/user/')) return 'user';\n  return 'agent';\n}\n\n/**\n * Paths that are legal to write **for this caller's scope**.\n *\n * If `scope.userId` is absent (isolated/autonomous agent), the user-tier\n * paths are dropped. This is the list the flush prompt renders into its\n * rubric — the LLM never sees paths it cannot write to.\n */\nexport function getWritablePathsForScope(\n  scope: Pick<MemoryScope, 'userId'>\n): readonly MemoryPathDescriptor[] {\n  if (scope.userId == null || scope.userId === '') {\n    return MEMORY_AGENT_PATHS;\n  }\n  return MEMORY_ALL_PATHS;\n}\n\n/**\n * Validates a write path against the whitelist AND the caller's scope.\n *\n * Throws with an actionable message when:\n * - the path is missing the `memory/` prefix\n * - the path is not on the 8-doc whitelist\n * - the path is user-tier but `scope.userId` is missing\n *\n * The store's append() is the single call site; other callers should\n * never hit this directly. Kept as a standalone function for testability.\n */\nexport function assertWritablePath(\n  path: string,\n  scope: Pick<MemoryScope, 'userId'>\n): MemoryPathDescriptor {\n  if (!path || !path.startsWith(MEMORY_PATH_PREFIX)) {\n    throw new Error(\n      `memory_append path must start with \"${MEMORY_PATH_PREFIX}\" (received \"${path}\")`\n    );\n  }\n  const descriptor = PATH_INDEX.get(path);\n  if (!descriptor) {\n    throw new Error(\n      `memory_append path \"${path}\" is not on the canonical whitelist. ` +\n        `Allowed: ${MEMORY_ALL_PATHS.map((p) => p.path).join(', ')}`\n    );\n  }\n  if (\n    descriptor.tier === 'user' &&\n    (scope.userId == null || scope.userId === '')\n  ) {\n    throw new Error(\n      `memory_append to user-tier path \"${path}\" requires a caller userId in scope, ` +\n        `but scope.userId is missing. This path is private to a specific user and ` +\n        `cannot be written from an isolated/autonomous context.`\n    );\n  }\n  return descriptor;\n}\n\n/**\n * Renders the whitelist as a compact bullet list, used inside the flush\n * prompt so the LLM sees the authoritative rubric at inference time.\n *\n * Output shape:\n *   - memory/agent/playbook.md [Playbook, shared] — <description>\n *   - memory/agent/pitfalls.md [Pitfalls, shared] — <description>\n *   ...\n *\n * The `[Label, shared|private]` tag tells the model whether the doc is\n * visible to all users (agent tier) or only to the caller (user tier).\n * Filtered to only the paths writable for the given scope.\n */\nexport function renderPathsRubric(scope: Pick<MemoryScope, 'userId'>): string {\n  const writable = getWritablePathsForScope(scope);\n  return writable\n    .map((p) => {\n      const visibility = p.tier === 'agent' ? 'shared' : 'private';\n      return `- ${p.path} [${p.label}, ${visibility}] — ${p.description}`;\n    })\n    .join('\\n');\n}\n"],"names":["MEMORY_PATH_PREFIX"],"mappings":"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"}

package/dist/cjs/memory/pgvectorStore.cjs

@@ -0,0 +1,225 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var embeddings = require('./embeddings.cjs');
+var mmr = require('./mmr.cjs');
+var temporalDecay = require('./temporalDecay.cjs');
+var citations = require('./citations.cjs');
+var paths = require('./paths.cjs');
+
+function assertScope(scope) {
+    if (!scope || !scope.agentId) {
+        throw new Error('MemoryScope { agentId } is required — agentId must be non-empty');
+    }
+}
+/** pgvector literal format: "[0.1,0.2,...]". */
+function toVectorLiteral(vec) {
+    return `[${vec.join(',')}]`;
+}
+/**
+ * Normalize caller userId for the layered read filter.
+ *
+ * The SQL filter is `(user_id IS NULL OR user_id = $2)`, so an empty
+ * string from the caller must not match rows whose user_id was set.
+ * We coerce empty/null/undefined to `null`, and pg treats `$2 = null`
+ * as `false` — which is exactly what we want for isolated callers:
+ * they see only agent-tier rows and nothing in the user tier.
+ */
+function normalizeCallerId(scope) {
+    const raw = scope.userId;
+    if (raw == null || raw === '')
+        return null;
+    return String(raw);
+}
+class PgvectorMemoryStore {
+    kind = 'vector';
+    pool;
+    table;
+    embedder;
+    constructor(opts) {
+        this.pool = opts.pool;
+        this.table = opts.table ?? constants.DEFAULT_MEMORY_TABLE;
+        this.embedder = opts.embedder ?? embeddings.getMemoryEmbedder();
+    }
+    async search(scope, query, opts = {}) {
+        assertScope(scope);
+        const trimmed = query.trim();
+        if (!trimmed)
+            return [];
+        const maxResults = Math.max(1, opts.maxResults ?? constants.DEFAULT_MAX_SEARCH_RESULTS);
+        const minScore = opts.minScore ?? constants.DEFAULT_MIN_SCORE;
+        const vector = await this.embedder.embed(trimmed);
+        const vectorLiteral = toVectorLiteral(vector);
+        const callerId = normalizeCallerId(scope);
+        // [memory-layered-search] debug: layered scope filter
+        //   agent-tier rows (user_id IS NULL) + this caller's user-tier rows.
+        //   Another user's rows are invisible at the SQL layer.
+        const sql = `
+      WITH scored AS (
+        SELECT
+          id,
+          path,
+          content,
+          created_at,
+          user_id,
+          (1 - (embedding <=> $1::vector)) AS vector_score,
+          ts_rank(tsv, plainto_tsquery('english', $2)) AS text_score
+        FROM ${this.table}
+        WHERE agent_id = $3
+          AND (user_id IS NULL OR user_id = $4)
+      )
+      SELECT
+        id,
+        path,
+        content,
+        created_at,
+        user_id,
+        (${constants.HYBRID_VECTOR_WEIGHT} * vector_score + ${constants.HYBRID_TEXT_WEIGHT} * text_score) AS score
+      FROM scored
+      WHERE (${constants.HYBRID_VECTOR_WEIGHT} * vector_score + ${constants.HYBRID_TEXT_WEIGHT} * text_score) >= $5
+      ORDER BY score DESC
+      LIMIT $6
+    `;
+        const { rows } = await this.pool.query(sql, [
+            vectorLiteral,
+            trimmed,
+            scope.agentId,
+            callerId,
+            minScore,
+            maxResults,
+        ]);
+        let hits = rows.map((row) => ({
+            id: String(row.id),
+            path: row.path,
+            content: row.content,
+            createdAt: new Date(row.created_at),
+            score: Number(row.score),
+            source: 'vector',
+            tier: paths.getTierForPath(row.path),
+        }));
+        // Phase 2: temporal decay (before MMR so diversity sees post-decay ranks)
+        if (opts.temporalDecay?.enabled) {
+            hits = temporalDecay.applyTemporalDecayToHits(hits, opts.temporalDecay);
+            hits.sort((a, b) => b.score - a.score);
+        }
+        // Phase 2: MMR reranking
+        if (opts.mmr?.enabled) {
+            hits = mmr.applyMMRToMemoryHits(hits, opts.mmr);
+        }
+        // Phase 2: citations (decorate last — mutates content with Source: trailer)
+        const citationsMode = opts.citations ?? 'auto';
+        if (citations.shouldIncludeCitations(citationsMode)) {
+            hits = citations.decorateCitations(hits, true);
+        }
+        return hits;
+    }
+    async get(scope, opts) {
+        assertScope(scope);
+        if (!opts.path)
+            return null;
+        const callerId = normalizeCallerId(scope);
+        const tier = paths.getTierForPath(opts.path);
+        // Agent-tier rows always live under user_id=NULL. User-tier rows
+        // always carry the caller's id. Querying with a precise predicate
+        // is faster than leaving it open AND guarantees a user cannot
+        // read another user's row even if they know the path by heart.
+        const userClause = tier === 'agent' ? 'user_id IS NULL' : 'user_id = $3';
+        const params = [scope.agentId, opts.path];
+        if (tier === 'user')
+            params.push(callerId);
+        const sql = `
+      SELECT content
+      FROM ${this.table}
+      WHERE agent_id = $1 AND path = $2 AND ${userClause}
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `;
+        const { rows } = await this.pool.query(sql, params);
+        if (rows.length === 0)
+            return null;
+        const text = String(rows[0].content ?? '');
+        if (opts.from == null && opts.lines == null) {
+            return { path: opts.path, text };
+        }
+        const allLines = text.split('\n');
+        const fromIdx = Math.max(0, (opts.from ?? 1) - 1);
+        const count = Math.max(0, opts.lines ?? allLines.length - fromIdx);
+        const slice = allLines.slice(fromIdx, fromIdx + count).join('\n');
+        return { path: opts.path, text: slice };
+    }
+    async append(scope, input) {
+        assertScope(scope);
+        // Whitelist + tier + scope-compatibility check in one call. Throws
+        // with an actionable message for each failure mode.
+        const descriptor = paths.assertWritablePath(input.path, scope);
+        const content = input.content.trim();
+        if (!content) {
+            throw new Error('memory_append content must be non-empty');
+        }
+        // Tier determines the row's user_id:
+        //   agent tier → NULL (shared across all users)
+        //   user tier  → the caller's id (assertWritablePath guarantees non-empty)
+        const rowUserId = descriptor.tier === 'agent' ? null : String(scope.userId);
+        const provenance = scope.userId != null ? String(scope.userId) : null;
+        // Read the existing row (if any) for THIS tier so we can embed the
+        // merged content. Agent-tier merges regardless of caller; user-tier
+        // merges only within the caller's own row.
+        const lookupSql = `
+      SELECT content FROM ${this.table}
+      WHERE agent_id = $1 AND path = $2 AND ${rowUserId === null ? 'user_id IS NULL' : 'user_id = $3'}
+      LIMIT 1
+    `;
+        const lookupParams = rowUserId === null
+            ? [scope.agentId, input.path]
+            : [scope.agentId, input.path, rowUserId];
+        const existing = await this.pool.query(lookupSql, lookupParams);
+        const priorContent = existing.rows.length > 0 ? String(existing.rows[0].content ?? '') : '';
+        const mergedContent = priorContent
+            ? `${priorContent.replace(/\s+$/, '')}\n\n${content}`
+            : content;
+        const vector = await this.embedder.embed(mergedContent);
+        const vectorLiteral = toVectorLiteral(vector);
+        // UPSERT on (agent_id, user_id, path) with NULLS NOT DISTINCT so
+        // two NULL user_ids collide on the same agent+path (exactly one
+        // agent-tier row) while per-user rows on the same path coexist.
+        //
+        // Provenance note: `last_user_id` always records WHO wrote the
+        // latest append, even for agent-tier rows where the row's own
+        // `user_id` stays NULL. That gives the admin UI an audit trail
+        // ("agent-tier row last updated by Alice") without changing the
+        // scoping semantics.
+        const upsertSql = `
+      INSERT INTO ${this.table} (agent_id, user_id, path, content, embedding, last_user_id, updated_at)
+      VALUES ($1, $2, $3, $4, $5::vector, $6, NOW())
+      ON CONFLICT (agent_id, user_id, path) DO UPDATE
+      SET content      = EXCLUDED.content,
+          embedding    = EXCLUDED.embedding,
+          last_user_id = EXCLUDED.last_user_id,
+          updated_at   = NOW()
+    `;
+        await this.pool.query(upsertSql, [
+            scope.agentId,
+            rowUserId,
+            input.path,
+            mergedContent,
+            vectorLiteral,
+            provenance,
+        ]);
+    }
+    async health() {
+        try {
+            await this.pool.query('SELECT 1');
+            return { ok: true, backend: 'vector' };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                backend: 'vector',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}
+
+exports.PgvectorMemoryStore = PgvectorMemoryStore;
+//# sourceMappingURL=pgvectorStore.cjs.map

package/dist/cjs/memory/pgvectorStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgvectorStore.cjs","sources":["../../../src/memory/pgvectorStore.ts"],"sourcesContent":["/**\n * Postgres + pgvector implementation of {@link MemoryBackend}.\n *\n * ## Scoping model (two-tier, layered)\n *\n * Every read query applies the layered filter\n *\n *   WHERE agent_id = $1 AND (user_id IS NULL OR user_id = $2)\n *\n * so the caller sees:\n *   - agent-tier rows (`user_id IS NULL`) — shared operational knowledge,\n *     visible to every user of the agent\n *   - their own user-tier rows (`user_id = <caller>`) — private per-user\n *     personalization\n *\n * Another user's user-tier rows are invisible — the privacy boundary is\n * enforced in SQL, not just in the UI or route layer.\n *\n * ## Writes\n *\n * `append()` routes to a row based on the path's tier, resolved via\n * {@link assertWritablePath}:\n *\n *   - `memory/agent/*` → stored with `user_id = NULL` regardless of\n *     what scope the caller passed. Agent-tier content is inherently\n *     shared; scoping it per-user would defeat the point.\n *   - `memory/user/*`  → stored with `user_id = scope.userId`. A missing\n *     `scope.userId` throws — user-tier paths cannot be written from\n *     isolated/autonomous contexts.\n *\n * UPSERT key is `(agent_id, user_id, path)` with `NULLS NOT DISTINCT`,\n * so each user gets their own `user/preferences.md` row and there is\n * exactly one `agent/playbook.md` row shared across the whole user base.\n * Content accumulates via `\\n\\n` concatenation on conflict, with the\n * embedding regenerated over the merged content so search stays\n * consistent.\n */\nimport type { Pool } from 'pg';\nimport {\n  DEFAULT_MAX_SEARCH_RESULTS,\n  DEFAULT_MEMORY_TABLE,\n  DEFAULT_MIN_SCORE,\n  HYBRID_TEXT_WEIGHT,\n  HYBRID_VECTOR_WEIGHT,\n} from './constants';\nimport { getMemoryEmbedder, type EmbeddingProvider } from './embeddings';\nimport { applyMMRToMemoryHits } from './mmr';\nimport { applyTemporalDecayToHits } from './temporalDecay';\nimport { decorateCitations, shouldIncludeCitations } from './citations';\nimport { assertWritablePath, getTierForPath } from './paths';\nimport type {\n  MemoryAppendInput,\n  MemoryBackend,\n  MemoryEntry,\n  MemoryGetOptions,\n  MemoryHealth,\n  MemoryReadResult,\n  MemoryScope,\n  MemorySearchOptions,\n} from './types';\n\nexport interface PgvectorStoreOptions {\n  pool: Pool;\n  table?: string;\n  embedder?: EmbeddingProvider;\n}\n\nfunction assertScope(scope: MemoryScope): void {\n  if (!scope || !scope.agentId) {\n    throw new Error(\n      'MemoryScope { agentId } is required — agentId must be non-empty'\n    );\n  }\n}\n\n/** pgvector literal format: \"[0.1,0.2,...]\". */\nfunction toVectorLiteral(vec: number[]): string {\n  return `[${vec.join(',')}]`;\n}\n\n/**\n * Normalize caller userId for the layered read filter.\n *\n * The SQL filter is `(user_id IS NULL OR user_id = $2)`, so an empty\n * string from the caller must not match rows whose user_id was set.\n * We coerce empty/null/undefined to `null`, and pg treats `$2 = null`\n * as `false` — which is exactly what we want for isolated callers:\n * they see only agent-tier rows and nothing in the user tier.\n */\nfunction normalizeCallerId(scope: MemoryScope): string | null {\n  const raw = scope.userId;\n  if (raw == null || raw === '') return null;\n  return String(raw);\n}\n\nexport class PgvectorMemoryStore implements MemoryBackend {\n  readonly kind = 'vector' as const;\n  private pool: Pool;\n  private table: string;\n  private embedder: EmbeddingProvider;\n\n  constructor(opts: PgvectorStoreOptions) {\n    this.pool = opts.pool;\n    this.table = opts.table ?? DEFAULT_MEMORY_TABLE;\n    this.embedder = opts.embedder ?? getMemoryEmbedder();\n  }\n\n  async search(\n    scope: MemoryScope,\n    query: string,\n    opts: MemorySearchOptions = {}\n  ): Promise<MemoryEntry[]> {\n    assertScope(scope);\n    const trimmed = query.trim();\n    if (!trimmed) return [];\n\n    const maxResults = Math.max(\n      1,\n      opts.maxResults ?? DEFAULT_MAX_SEARCH_RESULTS\n    );\n    const minScore = opts.minScore ?? DEFAULT_MIN_SCORE;\n\n    const vector = await this.embedder.embed(trimmed);\n    const vectorLiteral = toVectorLiteral(vector);\n    const callerId = normalizeCallerId(scope);\n\n    // [memory-layered-search] debug: layered scope filter\n    //   agent-tier rows (user_id IS NULL) + this caller's user-tier rows.\n    //   Another user's rows are invisible at the SQL layer.\n    const sql = `\n      WITH scored AS (\n        SELECT\n          id,\n          path,\n          content,\n          created_at,\n          user_id,\n          (1 - (embedding <=> $1::vector)) AS vector_score,\n          ts_rank(tsv, plainto_tsquery('english', $2)) AS text_score\n        FROM ${this.table}\n        WHERE agent_id = $3\n          AND (user_id IS NULL OR user_id = $4)\n      )\n      SELECT\n        id,\n        path,\n        content,\n        created_at,\n        user_id,\n        (${HYBRID_VECTOR_WEIGHT} * vector_score + ${HYBRID_TEXT_WEIGHT} * text_score) AS score\n      FROM scored\n      WHERE (${HYBRID_VECTOR_WEIGHT} * vector_score + ${HYBRID_TEXT_WEIGHT} * text_score) >= $5\n      ORDER BY score DESC\n      LIMIT $6\n    `;\n\n    const { rows } = await this.pool.query(sql, [\n      vectorLiteral,\n      trimmed,\n      scope.agentId,\n      callerId,\n      minScore,\n      maxResults,\n    ]);\n\n    let hits: MemoryEntry[] = rows.map(\n      (row: {\n        id: string | number;\n        path: string;\n        content: string;\n        created_at: Date;\n        user_id: string | null;\n        score: string | number;\n      }): MemoryEntry => ({\n        id: String(row.id),\n        path: row.path,\n        content: row.content,\n        createdAt: new Date(row.created_at),\n        score: Number(row.score),\n        source: 'vector',\n        tier: getTierForPath(row.path),\n      })\n    );\n\n    // Phase 2: temporal decay (before MMR so diversity sees post-decay ranks)\n    if (opts.temporalDecay?.enabled) {\n      hits = applyTemporalDecayToHits(hits, opts.temporalDecay);\n      hits.sort((a, b) => b.score - a.score);\n    }\n\n    // Phase 2: MMR reranking\n    if (opts.mmr?.enabled) {\n      hits = applyMMRToMemoryHits(hits, opts.mmr);\n    }\n\n    // Phase 2: citations (decorate last — mutates content with Source: trailer)\n    const citationsMode = opts.citations ?? 'auto';\n    if (shouldIncludeCitations(citationsMode)) {\n      hits = decorateCitations(hits, true);\n    }\n\n    return hits;\n  }\n\n  async get(\n    scope: MemoryScope,\n    opts: MemoryGetOptions\n  ): Promise<MemoryReadResult | null> {\n    assertScope(scope);\n    if (!opts.path) return null;\n\n    const callerId = normalizeCallerId(scope);\n    const tier = getTierForPath(opts.path);\n\n    // Agent-tier rows always live under user_id=NULL. User-tier rows\n    // always carry the caller's id. Querying with a precise predicate\n    // is faster than leaving it open AND guarantees a user cannot\n    // read another user's row even if they know the path by heart.\n    const userClause = tier === 'agent' ? 'user_id IS NULL' : 'user_id = $3';\n\n    const params: unknown[] = [scope.agentId, opts.path];\n    if (tier === 'user') params.push(callerId);\n\n    const sql = `\n      SELECT content\n      FROM ${this.table}\n      WHERE agent_id = $1 AND path = $2 AND ${userClause}\n      ORDER BY updated_at DESC\n      LIMIT 1\n    `;\n    const { rows } = await this.pool.query(sql, params);\n    if (rows.length === 0) return null;\n\n    const text = String(rows[0].content ?? '');\n    if (opts.from == null && opts.lines == null) {\n      return { path: opts.path, text };\n    }\n\n    const allLines = text.split('\\n');\n    const fromIdx = Math.max(0, (opts.from ?? 1) - 1);\n    const count = Math.max(0, opts.lines ?? allLines.length - fromIdx);\n    const slice = allLines.slice(fromIdx, fromIdx + count).join('\\n');\n    return { path: opts.path, text: slice };\n  }\n\n  async append(scope: MemoryScope, input: MemoryAppendInput): Promise<void> {\n    assertScope(scope);\n    // Whitelist + tier + scope-compatibility check in one call. Throws\n    // with an actionable message for each failure mode.\n    const descriptor = assertWritablePath(input.path, scope);\n    const content = input.content.trim();\n    if (!content) {\n      throw new Error('memory_append content must be non-empty');\n    }\n\n    // Tier determines the row's user_id:\n    //   agent tier → NULL (shared across all users)\n    //   user tier  → the caller's id (assertWritablePath guarantees non-empty)\n    const rowUserId = descriptor.tier === 'agent' ? null : String(scope.userId);\n    const provenance = scope.userId != null ? String(scope.userId) : null;\n\n    // Read the existing row (if any) for THIS tier so we can embed the\n    // merged content. Agent-tier merges regardless of caller; user-tier\n    // merges only within the caller's own row.\n    const lookupSql = `\n      SELECT content FROM ${this.table}\n      WHERE agent_id = $1 AND path = $2 AND ${rowUserId === null ? 'user_id IS NULL' : 'user_id = $3'}\n      LIMIT 1\n    `;\n    const lookupParams: unknown[] =\n      rowUserId === null\n        ? [scope.agentId, input.path]\n        : [scope.agentId, input.path, rowUserId];\n    const existing = await this.pool.query(lookupSql, lookupParams);\n    const priorContent: string =\n      existing.rows.length > 0 ? String(existing.rows[0].content ?? '') : '';\n    const mergedContent = priorContent\n      ? `${priorContent.replace(/\\s+$/, '')}\\n\\n${content}`\n      : content;\n\n    const vector = await this.embedder.embed(mergedContent);\n    const vectorLiteral = toVectorLiteral(vector);\n\n    // UPSERT on (agent_id, user_id, path) with NULLS NOT DISTINCT so\n    // two NULL user_ids collide on the same agent+path (exactly one\n    // agent-tier row) while per-user rows on the same path coexist.\n    //\n    // Provenance note: `last_user_id` always records WHO wrote the\n    // latest append, even for agent-tier rows where the row's own\n    // `user_id` stays NULL. That gives the admin UI an audit trail\n    // (\"agent-tier row last updated by Alice\") without changing the\n    // scoping semantics.\n    const upsertSql = `\n      INSERT INTO ${this.table} (agent_id, user_id, path, content, embedding, last_user_id, updated_at)\n      VALUES ($1, $2, $3, $4, $5::vector, $6, NOW())\n      ON CONFLICT (agent_id, user_id, path) DO UPDATE\n      SET content      = EXCLUDED.content,\n          embedding    = EXCLUDED.embedding,\n          last_user_id = EXCLUDED.last_user_id,\n          updated_at   = NOW()\n    `;\n    await this.pool.query(upsertSql, [\n      scope.agentId,\n      rowUserId,\n      input.path,\n      mergedContent,\n      vectorLiteral,\n      provenance,\n    ]);\n  }\n\n  async health(): Promise<MemoryHealth> {\n    try {\n      await this.pool.query('SELECT 1');\n      return { ok: true, backend: 'vector' };\n    } catch (err) {\n      return {\n        ok: false,\n        backend: 'vector',\n        error: err instanceof Error ? err.message : String(err),\n      };\n    }\n  }\n}\n"],"names":["DEFAULT_MEMORY_TABLE","getMemoryEmbedder","DEFAULT_MAX_SEARCH_RESULTS","DEFAULT_MIN_SCORE","HYBRID_VECTOR_WEIGHT","HYBRID_TEXT_WEIGHT","getTierForPath","applyTemporalDecayToHits","applyMMRToMemoryHits","shouldIncludeCitations","decorateCitations","assertWritablePath"],"mappings":"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"}

package/dist/cjs/memory/recallTracking.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var crypto = require('crypto');
+
+/**
+ * Recall tracking — Phase 2.
+ *
+ * Lightweight adaptation of upstream
+ * `extensions/memory-core/src/short-term-promotion.ts::recordShortTermRecalls`.
+ * Upstream stores recalls in a JSON file under `memory/.dreams/`; we store
+ * them in a Postgres table `agent_memory_recalls`. Schema captures what the
+ * future Phase 3 dreaming/promotion algorithm will need:
+ *   - which memory row was surfaced (`memory_id`)
+ *   - the query that surfaced it (raw + SHA-256 hash for dedupe)
+ *   - hybrid score at the time of recall
+ *   - the day bucket (for per-day dedupe / frequency counting)
+ *   - the recorded timestamp
+ *
+ * Best-effort: failures never block memory_search. The caller fires
+ * {@link RecallTracker.record} without awaiting the result and ignores errors.
+ */
+const RECALL_TABLE = 'agent_memory_recalls';
+function hashQuery(query) {
+    return crypto.createHash('sha256')
+        .update(query.trim().toLowerCase())
+        .digest('hex')
+        .slice(0, 32);
+}
+function dayBucket(nowMs) {
+    const d = new Date(nowMs);
+    const y = d.getUTCFullYear();
+    const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(d.getUTCDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+}
+class PgvectorRecallTracker {
+    pool;
+    table;
+    constructor(pool, table = RECALL_TABLE) {
+        this.pool = pool;
+        this.table = table;
+    }
+    async migrate() {
+        // [recall-tracking] debug: create table + indexes if missing
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        id           BIGSERIAL   PRIMARY KEY,
+        agent_id     TEXT        NOT NULL,
+        memory_id    TEXT        NOT NULL,
+        memory_path  TEXT        NOT NULL,
+        query        TEXT        NOT NULL,
+        query_hash   TEXT        NOT NULL,
+        score        DOUBLE PRECISION NOT NULL,
+        day_bucket   TEXT        NOT NULL,
+        recorded_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS ${this.table}_agent_day_idx ON ${this.table} (agent_id, day_bucket)`);
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS ${this.table}_memory_idx ON ${this.table} (agent_id, memory_id)`);
+        await this.pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${this.table}_dedupe_idx
+       ON ${this.table} (agent_id, memory_id, query_hash, day_bucket)`);
+    }
+    async record(params) {
+        if (!params.agentId || !params.query.trim() || params.hits.length === 0)
+            return;
+        const nowMs = params.nowMs ?? Date.now();
+        const qhash = hashQuery(params.query);
+        const bucket = dayBucket(nowMs);
+        // [recall-tracking] debug: upsert one row per (agent, memory, query, day)
+        // Upstream dedupes per-day per-query so repeated searches don't inflate counts.
+        const values = [];
+        const args = [];
+        let i = 1;
+        for (const hit of params.hits) {
+            values.push(`($${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, NOW())`);
+            args.push(params.agentId, hit.id, hit.path, params.query, qhash, hit.score, bucket);
+        }
+        const sql = `
+      INSERT INTO ${this.table}
+        (agent_id, memory_id, memory_path, query, query_hash, score, day_bucket, recorded_at)
+      VALUES ${values.join(', ')}
+      ON CONFLICT (agent_id, memory_id, query_hash, day_bucket) DO UPDATE
+      SET score       = GREATEST(${this.table}.score, EXCLUDED.score),
+          recorded_at = NOW()
+    `;
+        await this.pool.query(sql, args);
+    }
+}
+/** No-op tracker — used when recall tracking is disabled or the backend isn't pgvector. */
+class NullRecallTracker {
+    async record() { }
+    async migrate() { }
+}
+
+exports.NullRecallTracker = NullRecallTracker;
+exports.PgvectorRecallTracker = PgvectorRecallTracker;
+exports.RECALL_TABLE = RECALL_TABLE;
+//# sourceMappingURL=recallTracking.cjs.map

package/dist/cjs/memory/recallTracking.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recallTracking.cjs","sources":["../../../src/memory/recallTracking.ts"],"sourcesContent":["/**\n * Recall tracking — Phase 2.\n *\n * Lightweight adaptation of upstream\n * `extensions/memory-core/src/short-term-promotion.ts::recordShortTermRecalls`.\n * Upstream stores recalls in a JSON file under `memory/.dreams/`; we store\n * them in a Postgres table `agent_memory_recalls`. Schema captures what the\n * future Phase 3 dreaming/promotion algorithm will need:\n *   - which memory row was surfaced (`memory_id`)\n *   - the query that surfaced it (raw + SHA-256 hash for dedupe)\n *   - hybrid score at the time of recall\n *   - the day bucket (for per-day dedupe / frequency counting)\n *   - the recorded timestamp\n *\n * Best-effort: failures never block memory_search. The caller fires\n * {@link RecallTracker.record} without awaiting the result and ignores errors.\n */\nimport { createHash } from 'crypto';\nimport type { Pool } from 'pg';\n\nexport interface RecallTracker {\n  /** Record that the given memory ids were surfaced to the model for a query. */\n  record(params: RecallRecordParams): Promise<void>;\n  /** Backend-specific schema migration. Idempotent. */\n  migrate(): Promise<void>;\n}\n\nexport interface RecallRecordParams {\n  agentId: string;\n  query: string;\n  hits: Array<{ id: string; path: string; score: number }>;\n  nowMs?: number;\n}\n\nexport const RECALL_TABLE = 'agent_memory_recalls';\n\nfunction hashQuery(query: string): string {\n  return createHash('sha256')\n    .update(query.trim().toLowerCase())\n    .digest('hex')\n    .slice(0, 32);\n}\n\nfunction dayBucket(nowMs: number): string {\n  const d = new Date(nowMs);\n  const y = d.getUTCFullYear();\n  const m = String(d.getUTCMonth() + 1).padStart(2, '0');\n  const day = String(d.getUTCDate()).padStart(2, '0');\n  return `${y}-${m}-${day}`;\n}\n\nexport class PgvectorRecallTracker implements RecallTracker {\n  constructor(\n    private readonly pool: Pool,\n    private readonly table: string = RECALL_TABLE\n  ) {}\n\n  async migrate(): Promise<void> {\n    // [recall-tracking] debug: create table + indexes if missing\n    await this.pool.query(`\n      CREATE TABLE IF NOT EXISTS ${this.table} (\n        id           BIGSERIAL   PRIMARY KEY,\n        agent_id     TEXT        NOT NULL,\n        memory_id    TEXT        NOT NULL,\n        memory_path  TEXT        NOT NULL,\n        query        TEXT        NOT NULL,\n        query_hash   TEXT        NOT NULL,\n        score        DOUBLE PRECISION NOT NULL,\n        day_bucket   TEXT        NOT NULL,\n        recorded_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()\n      )\n    `);\n    await this.pool.query(\n      `CREATE INDEX IF NOT EXISTS ${this.table}_agent_day_idx ON ${this.table} (agent_id, day_bucket)`\n    );\n    await this.pool.query(\n      `CREATE INDEX IF NOT EXISTS ${this.table}_memory_idx ON ${this.table} (agent_id, memory_id)`\n    );\n    await this.pool.query(\n      `CREATE UNIQUE INDEX IF NOT EXISTS ${this.table}_dedupe_idx\n       ON ${this.table} (agent_id, memory_id, query_hash, day_bucket)`\n    );\n  }\n\n  async record(params: RecallRecordParams): Promise<void> {\n    if (!params.agentId || !params.query.trim() || params.hits.length === 0)\n      return;\n    const nowMs = params.nowMs ?? Date.now();\n    const qhash = hashQuery(params.query);\n    const bucket = dayBucket(nowMs);\n\n    // [recall-tracking] debug: upsert one row per (agent, memory, query, day)\n    // Upstream dedupes per-day per-query so repeated searches don't inflate counts.\n    const values: string[] = [];\n    const args: unknown[] = [];\n    let i = 1;\n    for (const hit of params.hits) {\n      values.push(\n        `($${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, NOW())`\n      );\n      args.push(\n        params.agentId,\n        hit.id,\n        hit.path,\n        params.query,\n        qhash,\n        hit.score,\n        bucket\n      );\n    }\n    const sql = `\n      INSERT INTO ${this.table}\n        (agent_id, memory_id, memory_path, query, query_hash, score, day_bucket, recorded_at)\n      VALUES ${values.join(', ')}\n      ON CONFLICT (agent_id, memory_id, query_hash, day_bucket) DO UPDATE\n      SET score       = GREATEST(${this.table}.score, EXCLUDED.score),\n          recorded_at = NOW()\n    `;\n    await this.pool.query(sql, args);\n  }\n}\n\n/** No-op tracker — used when recall tracking is disabled or the backend isn't pgvector. */\nexport class NullRecallTracker implements RecallTracker {\n  async record(): Promise<void> {}\n  async migrate(): Promise<void> {}\n}\n"],"names":["createHash"],"mappings":"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"}