@illuma-ai/agents 1.1.25 → 1.3.0

package/dist/cjs/main.cjs

@@ -15,6 +15,7 @@ var summarize = require('./messages/summarize.cjs');
 var dedup = require('./messages/dedup.cjs');
 var Graph = require('./graphs/Graph.cjs');
 var MultiAgentGraph = require('./graphs/MultiAgentGraph.cjs');
+var HandoffRegistry = require('./graphs/HandoffRegistry.cjs');
 var Calculator = require('./tools/Calculator.cjs');
 var CodeExecutor = require('./tools/CodeExecutor.cjs');
 var BrowserTools = require('./tools/BrowserTools.cjs');
@@ -26,10 +27,26 @@ var schema$1 = require('./tools/schema.cjs');
 var handlers$1 = require('./tools/handlers.cjs');
 var tool = require('./tools/search/tool.cjs');
 var schema = require('./tools/search/schema.cjs');
+var index$2 = require('./tools/memory/index.cjs');
+var constants$2 = require('./memory/constants.cjs');
+var paths = require('./memory/paths.cjs');
+var pgvectorStore = require('./memory/pgvectorStore.cjs');
+var compositeBackend = require('./memory/compositeBackend.cjs');
+var embeddings = require('./memory/embeddings.cjs');
+var migrate = require('./memory/migrate.cjs');
+var factory = require('./memory/factory.cjs');
+var mmr = require('./memory/mmr.cjs');
+var temporalDecay = require('./memory/temporalDecay.cjs');
+var citations = require('./memory/citations.cjs');
+var recallTracking = require('./memory/recallTracking.cjs');
+var memoryFlushPrompt = require('./prompts/memoryFlushPrompt.cjs');
+var memoryFlushPhase = require('./graphs/phases/memoryFlushPhase.cjs');
+var flushLoop = require('./graphs/phases/flushLoop.cjs');
 var validate = require('./schemas/validate.cjs');
 var ApprovalGateNode = require('./nodes/ApprovalGateNode.cjs');
 var _enum = require('./common/enum.cjs');
 var constants$1 = require('./common/constants.cjs');
+var spawnPath = require('./common/spawnPath.cjs');
 var constants = require('./tools/approval/constants.cjs');
 var graph = require('./utils/graph.cjs');
 var llm = require('./utils/llm.cjs');
@@ -48,6 +65,10 @@ var fileManifest = require('./utils/fileManifest.cjs');
 var index$1 = require('./llm/openai/index.cjs');
 var index = require('./llm/openrouter/index.cjs');
 var providers = require('./llm/providers.cjs');
+var shared = require('./tools/memory/shared.cjs');
+var memoryAppendTool = require('./tools/memory/memoryAppendTool.cjs');
+var memoryGetTool = require('./tools/memory/memoryGetTool.cjs');
+var memorySearchTool = require('./tools/memory/memorySearchTool.cjs');
 
 
 
@@ -105,6 +126,7 @@ exports.deduplicateSystemMessages = dedup.deduplicateSystemMessages;
 exports.Graph = Graph.Graph;
 exports.StandardGraph = Graph.StandardGraph;
 exports.MultiAgentGraph = MultiAgentGraph.MultiAgentGraph;
+exports.HandoffRegistry = HandoffRegistry.HandoffRegistry;
 exports.Calculator = Calculator.Calculator;
 exports.CalculatorSchema = Calculator.CalculatorSchema;
 exports.CalculatorToolDefinition = Calculator.CalculatorToolDefinition;
@@ -182,6 +204,81 @@ exports.imagesSchema = schema.imagesSchema;
 exports.newsSchema = schema.newsSchema;
 exports.querySchema = schema.querySchema;
 exports.videosSchema = schema.videosSchema;
+exports.buildMemoryTools = index$2.buildMemoryTools;
+exports.DEFAULT_CITATIONS_MODE = constants$2.DEFAULT_CITATIONS_MODE;
+exports.DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = constants$2.DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS;
+exports.DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = constants$2.DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS;
+exports.DEFAULT_MAX_APPENDS_PER_FLUSH = constants$2.DEFAULT_MAX_APPENDS_PER_FLUSH;
+exports.DEFAULT_MAX_FLUSH_ITERATIONS = constants$2.DEFAULT_MAX_FLUSH_ITERATIONS;
+exports.DEFAULT_MAX_INJECTED_CHARS = constants$2.DEFAULT_MAX_INJECTED_CHARS;
+exports.DEFAULT_MAX_SEARCH_RESULTS = constants$2.DEFAULT_MAX_SEARCH_RESULTS;
+exports.DEFAULT_MEMORY_DIMENSIONS = constants$2.DEFAULT_MEMORY_DIMENSIONS;
+exports.DEFAULT_MEMORY_FLUSH_PROMPT = constants$2.DEFAULT_MEMORY_FLUSH_PROMPT;
+exports.DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = constants$2.DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT;
+exports.DEFAULT_MEMORY_MODEL = constants$2.DEFAULT_MEMORY_MODEL;
+exports.DEFAULT_MEMORY_PROVIDER = constants$2.DEFAULT_MEMORY_PROVIDER;
+exports.DEFAULT_MEMORY_SCHEMA = constants$2.DEFAULT_MEMORY_SCHEMA;
+exports.DEFAULT_MEMORY_TABLE = constants$2.DEFAULT_MEMORY_TABLE;
+exports.DEFAULT_MIN_SCORE = constants$2.DEFAULT_MIN_SCORE;
+exports.DEFAULT_MMR_ENABLED = constants$2.DEFAULT_MMR_ENABLED;
+exports.DEFAULT_MMR_LAMBDA = constants$2.DEFAULT_MMR_LAMBDA;
+exports.DEFAULT_RECALL_TRACKING_ENABLED = constants$2.DEFAULT_RECALL_TRACKING_ENABLED;
+exports.DEFAULT_TEMPORAL_DECAY_ENABLED = constants$2.DEFAULT_TEMPORAL_DECAY_ENABLED;
+exports.DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = constants$2.DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS;
+exports.FLUSH_PROMPT_RUBRIC_PLACEHOLDER = constants$2.FLUSH_PROMPT_RUBRIC_PLACEHOLDER;
+exports.HYBRID_TEXT_WEIGHT = constants$2.HYBRID_TEXT_WEIGHT;
+exports.HYBRID_VECTOR_WEIGHT = constants$2.HYBRID_VECTOR_WEIGHT;
+exports.MEMORY_APPEND_DESCRIPTION = constants$2.MEMORY_APPEND_DESCRIPTION;
+exports.MEMORY_APPEND_TOOL_NAME = constants$2.MEMORY_APPEND_TOOL_NAME;
+exports.MEMORY_GET_DESCRIPTION = constants$2.MEMORY_GET_DESCRIPTION;
+exports.MEMORY_GET_TOOL_NAME = constants$2.MEMORY_GET_TOOL_NAME;
+exports.MEMORY_PATH_PREFIX = constants$2.MEMORY_PATH_PREFIX;
+exports.MEMORY_PHASE_FLUSHING = constants$2.MEMORY_PHASE_FLUSHING;
+exports.MEMORY_PHASE_NORMAL = constants$2.MEMORY_PHASE_NORMAL;
+exports.MEMORY_SEARCH_DESCRIPTION = constants$2.MEMORY_SEARCH_DESCRIPTION;
+exports.MEMORY_SEARCH_TOOL_NAME = constants$2.MEMORY_SEARCH_TOOL_NAME;
+exports.SILENT_REPLY_TOKEN = constants$2.SILENT_REPLY_TOKEN;
+exports.MEMORY_AGENT_PATHS = paths.MEMORY_AGENT_PATHS;
+exports.MEMORY_ALL_PATHS = paths.MEMORY_ALL_PATHS;
+exports.MEMORY_USER_PATHS = paths.MEMORY_USER_PATHS;
+exports.MEMORY_WRITABLE_PATHS = paths.MEMORY_WRITABLE_PATHS;
+exports.assertWritablePath = paths.assertWritablePath;
+exports.getPathDescriptor = paths.getPathDescriptor;
+exports.getTierForPath = paths.getTierForPath;
+exports.getWritablePathsForScope = paths.getWritablePathsForScope;
+exports.renderPathsRubric = paths.renderPathsRubric;
+exports.PgvectorMemoryStore = pgvectorStore.PgvectorMemoryStore;
+exports.CompositeMemoryBackend = compositeBackend.CompositeMemoryBackend;
+exports.getMemoryEmbedder = embeddings.getMemoryEmbedder;
+exports.resetMemoryEmbedder = embeddings.resetMemoryEmbedder;
+exports.runMemoryMigration = migrate.runMemoryMigration;
+exports.buildMemoryBackendFromEnv = factory.buildMemoryBackendFromEnv;
+exports.DEFAULT_MMR_CONFIG = mmr.DEFAULT_MMR_CONFIG;
+exports.applyMMRToMemoryHits = mmr.applyMMRToMemoryHits;
+exports.computeMMRScore = mmr.computeMMRScore;
+exports.jaccardSimilarity = mmr.jaccardSimilarity;
+exports.mmrRerank = mmr.mmrRerank;
+exports.textSimilarity = mmr.textSimilarity;
+exports.tokenize = mmr.tokenize;
+exports.DEFAULT_TEMPORAL_DECAY_CONFIG = temporalDecay.DEFAULT_TEMPORAL_DECAY_CONFIG;
+exports.applyTemporalDecayToHits = temporalDecay.applyTemporalDecayToHits;
+exports.applyTemporalDecayToScore = temporalDecay.applyTemporalDecayToScore;
+exports.calculateTemporalDecayMultiplier = temporalDecay.calculateTemporalDecayMultiplier;
+exports.isEvergreenMemoryPath = temporalDecay.isEvergreenMemoryPath;
+exports.parseMemoryDateFromPath = temporalDecay.parseMemoryDateFromPath;
+exports.decorateCitations = citations.decorateCitations;
+exports.resolveMemoryCitationsMode = citations.resolveMemoryCitationsMode;
+exports.shouldIncludeCitations = citations.shouldIncludeCitations;
+exports.NullRecallTracker = recallTracking.NullRecallTracker;
+exports.PgvectorRecallTracker = recallTracking.PgvectorRecallTracker;
+exports.RECALL_TABLE = recallTracking.RECALL_TABLE;
+exports.MEMORY_FLUSH_SYSTEM_PROMPT = memoryFlushPrompt.MEMORY_FLUSH_SYSTEM_PROMPT;
+exports.runMemoryFlush = memoryFlushPhase.runMemoryFlush;
+exports.shouldFlushMemory = memoryFlushPhase.shouldFlushMemory;
+exports.bindToolsIfSupported = flushLoop.bindToolsIfSupported;
+exports.extractFlushText = flushLoop.extractText;
+exports.parseFlushToolResult = flushLoop.parseToolResult;
+exports.runFlushLoop = flushLoop.runFlushLoop;
 exports.createValidationErrorMessage = validate.createValidationErrorMessage;
 exports.isValidJsonSchema = validate.isValidJsonSchema;
 exports.normalizeJsonSchema = validate.normalizeJsonSchema;
@@ -264,6 +361,14 @@ exports.SUMMARIZATION_CONTEXT_THRESHOLD = constants$1.SUMMARIZATION_CONTEXT_THRE
 exports.SUMMARIZATION_RESERVE_RATIO = constants$1.SUMMARIZATION_RESERVE_RATIO;
 exports.TOOL_DISCOVERY_CACHE_MAX_SIZE = constants$1.TOOL_DISCOVERY_CACHE_MAX_SIZE;
 exports.TOOL_TURN_THINKING_BUDGET = constants$1.TOOL_TURN_THINKING_BUDGET;
+exports.MAX_NESTING_DEPTH = spawnPath.MAX_NESTING_DEPTH;
+exports.SPAWN_PATH_SEP = spawnPath.SPAWN_PATH_SEP;
+exports.buildSpawnPath = spawnPath.buildSpawnPath;
+exports.isAncestorSpawnPath = spawnPath.isAncestorSpawnPath;
+exports.leafSpawnKey = spawnPath.leafSpawnKey;
+exports.parentSpawnPath = spawnPath.parentSpawnPath;
+exports.spawnPathDepth = spawnPath.spawnPathDepth;
+exports.spawnPathParts = spawnPath.spawnPathParts;
 Object.defineProperty(exports, "ActionCategory", {
 	enumerable: true,
 	get: function () { return constants.ActionCategory; }
@@ -324,4 +429,14 @@ exports.CustomOpenAIClient = index$1.CustomOpenAIClient;
 exports.ChatOpenRouter = index.ChatOpenRouter;
 exports.getChatModelClass = providers.getChatModelClass;
 exports.llmProviders = providers.llmProviders;
+exports.MemoryAppendSchema = shared.MemoryAppendSchema;
+exports.MemoryGetSchema = shared.MemoryGetSchema;
+exports.MemorySearchSchema = shared.MemorySearchSchema;
+exports.assertAppendAllowed = shared.assertAppendAllowed;
+exports.buildMemorySearchUnavailableResult = shared.buildMemorySearchUnavailableResult;
+exports.clampResultsByInjectedChars = shared.clampResultsByInjectedChars;
+exports.toAppendInput = shared.toAppendInput;
+exports.createMemoryAppendTool = memoryAppendTool.createMemoryAppendTool;
+exports.createMemoryGetTool = memoryGetTool.createMemoryGetTool;
+exports.createMemorySearchTool = memorySearchTool.createMemorySearchTool;
 //# sourceMappingURL=main.cjs.map

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/memory/citations.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Citation decoration — Phase 2.
+ *
+ * Ported from upstream `extensions/memory-core/src/tools.citations.ts`.
+ * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so
+ * the model can attribute claims back to specific memory files when it
+ * uses them in its answer.
+ *
+ * Since our backend stores files as single rows (not line-chunked), we
+ * compute line ranges from the returned content block on the fly:
+ *   - `startLine` = 1 (line 1 of the file)
+ *   - `endLine`   = total number of lines in the block
+ * This matches upstream's output format exactly while keeping the pg
+ * schema chunk-free.
+ */
+const DEFAULT_CITATIONS_MODE = 'auto';
+function resolveMemoryCitationsMode(raw) {
+    if (raw === 'on' || raw === 'off' || raw === 'auto')
+        return raw;
+    return DEFAULT_CITATIONS_MODE;
+}
+function countLines(text) {
+    if (!text)
+        return 1;
+    return Math.max(1, text.split('\n').length);
+}
+function formatCitation(path, startLine, endLine) {
+    if (startLine === endLine)
+        return `${path}#L${startLine}`;
+    return `${path}#L${startLine}-L${endLine}`;
+}
+/**
+ * Decorate each hit with a citation marker. Mirrors upstream's behavior:
+ * appends `\n\nSource: <citation>` to the content and sets `citation`.
+ * When `include=false`, clears any existing citation field.
+ */
+function decorateCitations(hits, include) {
+    if (!include)
+        return hits.map((h) => ({ ...h, citation: undefined }));
+    return hits.map((h) => {
+        const start = Math.max(1, Math.floor(h.startLine ?? 1));
+        const end = Math.max(start, Math.floor(h.endLine ?? countLines(h.content)));
+        const citation = formatCitation(h.path, start, end);
+        const content = `${(h.content ?? '').trimEnd()}\n\nSource: ${citation}`;
+        return { ...h, citation, content, startLine: start, endLine: end };
+    });
+}
+/**
+ * Whether citations should be emitted for this call.
+ *
+ * Upstream keys `auto` off the session type (direct/group/channel). In
+ * Phase 1 we only have direct chat, so `auto` => `on`. Callers that
+ * later distinguish session types can pass `mode` explicitly.
+ */
+function shouldIncludeCitations(mode) {
+    if (mode === 'on')
+        return true;
+    if (mode === 'off')
+        return false;
+    return true;
+}
+
+exports.DEFAULT_CITATIONS_MODE = DEFAULT_CITATIONS_MODE;
+exports.decorateCitations = decorateCitations;
+exports.resolveMemoryCitationsMode = resolveMemoryCitationsMode;
+exports.shouldIncludeCitations = shouldIncludeCitations;
+//# sourceMappingURL=citations.cjs.map

package/dist/cjs/memory/citations.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"citations.cjs","sources":["../../../src/memory/citations.ts"],"sourcesContent":["/**\n * Citation decoration — Phase 2.\n *\n * Ported from upstream `extensions/memory-core/src/tools.citations.ts`.\n * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so\n * the model can attribute claims back to specific memory files when it\n * uses them in its answer.\n *\n * Since our backend stores files as single rows (not line-chunked), we\n * compute line ranges from the returned content block on the fly:\n *   - `startLine` = 1 (line 1 of the file)\n *   - `endLine`   = total number of lines in the block\n * This matches upstream's output format exactly while keeping the pg\n * schema chunk-free.\n */\n\nexport type MemoryCitationsMode = 'on' | 'off' | 'auto';\n\nexport const DEFAULT_CITATIONS_MODE: MemoryCitationsMode = 'auto';\n\nexport function resolveMemoryCitationsMode(\n  raw: string | undefined | null\n): MemoryCitationsMode {\n  if (raw === 'on' || raw === 'off' || raw === 'auto') return raw;\n  return DEFAULT_CITATIONS_MODE;\n}\n\nexport interface CitationCandidate {\n  path: string;\n  content: string;\n  startLine?: number;\n  endLine?: number;\n  citation?: string;\n}\n\nfunction countLines(text: string): number {\n  if (!text) return 1;\n  return Math.max(1, text.split('\\n').length);\n}\n\nfunction formatCitation(\n  path: string,\n  startLine: number,\n  endLine: number\n): string {\n  if (startLine === endLine) return `${path}#L${startLine}`;\n  return `${path}#L${startLine}-L${endLine}`;\n}\n\n/**\n * Decorate each hit with a citation marker. Mirrors upstream's behavior:\n * appends `\\n\\nSource: <citation>` to the content and sets `citation`.\n * When `include=false`, clears any existing citation field.\n */\nexport function decorateCitations<T extends CitationCandidate>(\n  hits: T[],\n  include: boolean\n): T[] {\n  if (!include) return hits.map((h) => ({ ...h, citation: undefined }));\n  return hits.map((h) => {\n    const start = Math.max(1, Math.floor(h.startLine ?? 1));\n    const end = Math.max(start, Math.floor(h.endLine ?? countLines(h.content)));\n    const citation = formatCitation(h.path, start, end);\n    const content = `${(h.content ?? '').trimEnd()}\\n\\nSource: ${citation}`;\n    return { ...h, citation, content, startLine: start, endLine: end };\n  });\n}\n\n/**\n * Whether citations should be emitted for this call.\n *\n * Upstream keys `auto` off the session type (direct/group/channel). In\n * Phase 1 we only have direct chat, so `auto` => `on`. Callers that\n * later distinguish session types can pass `mode` explicitly.\n */\nexport function shouldIncludeCitations(mode: MemoryCitationsMode): boolean {\n  if (mode === 'on') return true;\n  if (mode === 'off') return false;\n  return true;\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;AAcG;AAII,MAAM,sBAAsB,GAAwB;AAErD,SAAU,0BAA0B,CACxC,GAA8B,EAAA;IAE9B,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM;AAAE,QAAA,OAAO,GAAG;AAC/D,IAAA,OAAO,sBAAsB;AAC/B;AAUA,SAAS,UAAU,CAAC,IAAY,EAAA;AAC9B,IAAA,IAAI,CAAC,IAAI;AAAE,QAAA,OAAO,CAAC;AACnB,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;AAC7C;AAEA,SAAS,cAAc,CACrB,IAAY,EACZ,SAAiB,EACjB,OAAe,EAAA;IAEf,IAAI,SAAS,KAAK,OAAO;AAAE,QAAA,OAAO,CAAA,EAAG,IAAI,CAAA,EAAA,EAAK,SAAS,EAAE;AACzD,IAAA,OAAO,GAAG,IAAI,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,EAAK,OAAO,EAAE;AAC5C;AAEA;;;;AAIG;AACG,SAAU,iBAAiB,CAC/B,IAAS,EACT,OAAgB,EAAA;AAEhB,IAAA,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;AACrE,IAAA,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAI;AACpB,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3E,QAAA,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;AACnD,QAAA,MAAM,OAAO,GAAG,CAAA,EAAG,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,EAAE,OAAO,EAAE,CAAA,YAAA,EAAe,QAAQ,EAAE;AACvE,QAAA,OAAO,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE;AACpE,IAAA,CAAC,CAAC;AACJ;AAEA;;;;;;AAMG;AACG,SAAU,sBAAsB,CAAC,IAAyB,EAAA;IAC9D,IAAI,IAAI,KAAK,IAAI;AAAE,QAAA,OAAO,IAAI;IAC9B,IAAI,IAAI,KAAK,KAAK;AAAE,QAAA,OAAO,KAAK;AAChC,IAAA,OAAO,IAAI;AACb;;;;;;;"}

package/dist/cjs/memory/compositeBackend.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+class CompositeMemoryBackend {
+    kind = 'composite';
+    backends;
+    constructor(backends) {
+        if (backends.length === 0) {
+            throw new Error('CompositeMemoryBackend requires at least one backend');
+        }
+        this.backends = backends;
+    }
+    async search(scope, query, opts) {
+        const perBackend = await Promise.all(this.backends.map((backend) => backend.search(scope, query, opts)));
+        const merged = new Map();
+        for (const entries of perBackend) {
+            for (const entry of entries) {
+                const key = `${entry.source ?? 'unknown'}:${entry.id}`;
+                const existing = merged.get(key);
+                if (!existing || entry.score > existing.score) {
+                    merged.set(key, entry);
+                }
+            }
+        }
+        const limit = Math.max(1, opts?.maxResults ?? 10);
+        return Array.from(merged.values())
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    async get(scope, opts) {
+        for (const backend of this.backends) {
+            const result = await backend.get(scope, opts);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    async append(scope, input) {
+        // Serial fan-out — a failure in an earlier backend means we stop and
+        // bubble. We do NOT want a partial write where the vector row landed but
+        // the graph backend quietly dropped the note.
+        for (const backend of this.backends) {
+            await backend.append(scope, input);
+        }
+    }
+    async health() {
+        const healths = await Promise.all(this.backends.map((b) => b.health()));
+        const failed = healths.find((h) => !h.ok);
+        if (failed) {
+            return {
+                ok: false,
+                backend: 'composite',
+                error: `${failed.backend}: ${failed.error ?? 'unhealthy'}`,
+            };
+        }
+        return { ok: true, backend: 'composite' };
+    }
+}
+
+exports.CompositeMemoryBackend = CompositeMemoryBackend;
+//# sourceMappingURL=compositeBackend.cjs.map

package/dist/cjs/memory/compositeBackend.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeBackend.cjs","sources":["../../../src/memory/compositeBackend.ts"],"sourcesContent":["/**\n * Composite memory backend — the architectural seam for a future graph layer.\n *\n * Today, memory is pgvector only. Tomorrow, a Graphiti or Neo4j-agent-memory\n * adapter can implement the same {@link MemoryBackend} interface and be\n * composed with the vector store here — without touching the tool\n * definitions, prompts, or host wiring.\n *\n * Fan-out strategy (simple on purpose for Phase 1):\n * - `search`: query every backend in parallel, merge, dedupe by id, sort by\n *   score, cap at maxResults. Graph hits and vector hits are interleaved by\n *   score — the LLM sees one ranked list.\n * - `get`: the vector store owns file paths; graph stores don't. First\n *   backend that returns a non-null result wins. In practice this will almost\n *   always be the vector store, since append paths live there.\n * - `append`: fan out to every backend. Vector store persists the note,\n *   graph backend runs its own extraction pipeline. An append failure in any\n *   single backend is surfaced — we fail loud rather than silently dropping\n *   writes.\n */\nimport type {\n  MemoryAppendInput,\n  MemoryBackend,\n  MemoryEntry,\n  MemoryGetOptions,\n  MemoryHealth,\n  MemoryReadResult,\n  MemoryScope,\n  MemorySearchOptions,\n} from './types';\n\nexport class CompositeMemoryBackend implements MemoryBackend {\n  readonly kind = 'composite' as const;\n  private readonly backends: MemoryBackend[];\n\n  constructor(backends: MemoryBackend[]) {\n    if (backends.length === 0) {\n      throw new Error('CompositeMemoryBackend requires at least one backend');\n    }\n    this.backends = backends;\n  }\n\n  async search(\n    scope: MemoryScope,\n    query: string,\n    opts?: MemorySearchOptions\n  ): Promise<MemoryEntry[]> {\n    const perBackend = await Promise.all(\n      this.backends.map((backend) => backend.search(scope, query, opts))\n    );\n    const merged = new Map<string, MemoryEntry>();\n    for (const entries of perBackend) {\n      for (const entry of entries) {\n        const key = `${entry.source ?? 'unknown'}:${entry.id}`;\n        const existing = merged.get(key);\n        if (!existing || entry.score > existing.score) {\n          merged.set(key, entry);\n        }\n      }\n    }\n    const limit = Math.max(1, opts?.maxResults ?? 10);\n    return Array.from(merged.values())\n      .sort((a, b) => b.score - a.score)\n      .slice(0, limit);\n  }\n\n  async get(\n    scope: MemoryScope,\n    opts: MemoryGetOptions\n  ): Promise<MemoryReadResult | null> {\n    for (const backend of this.backends) {\n      const result = await backend.get(scope, opts);\n      if (result) return result;\n    }\n    return null;\n  }\n\n  async append(scope: MemoryScope, input: MemoryAppendInput): Promise<void> {\n    // Serial fan-out — a failure in an earlier backend means we stop and\n    // bubble. We do NOT want a partial write where the vector row landed but\n    // the graph backend quietly dropped the note.\n    for (const backend of this.backends) {\n      await backend.append(scope, input);\n    }\n  }\n\n  async health(): Promise<MemoryHealth> {\n    const healths = await Promise.all(this.backends.map((b) => b.health()));\n    const failed = healths.find((h) => !h.ok);\n    if (failed) {\n      return {\n        ok: false,\n        backend: 'composite',\n        error: `${failed.backend}: ${failed.error ?? 'unhealthy'}`,\n      };\n    }\n    return { ok: true, backend: 'composite' };\n  }\n}\n"],"names":[],"mappings":";;MA+Ba,sBAAsB,CAAA;IACxB,IAAI,GAAG,WAAoB;AACnB,IAAA,QAAQ;AAEzB,IAAA,WAAA,CAAY,QAAyB,EAAA;AACnC,QAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,YAAA,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC;QACzE;AACA,QAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;IAC1B;AAEA,IAAA,MAAM,MAAM,CACV,KAAkB,EAClB,KAAa,EACb,IAA0B,EAAA;AAE1B,QAAA,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CACnE;AACD,QAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB;AAC7C,QAAA,KAAK,MAAM,OAAO,IAAI,UAAU,EAAE;AAChC,YAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;AAC3B,gBAAA,MAAM,GAAG,GAAG,CAAA,EAAG,KAAK,CAAC,MAAM,IAAI,SAAS,CAAA,CAAA,EAAI,KAAK,CAAC,EAAE,EAAE;gBACtD,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBAChC,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,EAAE;AAC7C,oBAAA,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;gBACxB;YACF;QACF;AACA,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,IAAI,EAAE,CAAC;QACjD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;AAC9B,aAAA,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK;AAChC,aAAA,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;IACpB;AAEA,IAAA,MAAM,GAAG,CACP,KAAkB,EAClB,IAAsB,EAAA;AAEtB,QAAA,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YACnC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC;AAC7C,YAAA,IAAI,MAAM;AAAE,gBAAA,OAAO,MAAM;QAC3B;AACA,QAAA,OAAO,IAAI;IACb;AAEA,IAAA,MAAM,MAAM,CAAC,KAAkB,EAAE,KAAwB,EAAA;;;;AAIvD,QAAA,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YACnC,MAAM,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC;QACpC;IACF;AAEA,IAAA,MAAM,MAAM,GAAA;QACV,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AACvE,QAAA,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,IAAI,MAAM,EAAE;YACV,OAAO;AACL,gBAAA,EAAE,EAAE,KAAK;AACT,gBAAA,OAAO,EAAE,WAAW;gBACpB,KAAK,EAAE,CAAA,EAAG,MAAM,CAAC,OAAO,CAAA,EAAA,EAAK,MAAM,CAAC,KAAK,IAAI,WAAW,CAAA,CAAE;aAC3D;QACH;QACA,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;IAC3C;AACD;;;;"}

package/dist/cjs/memory/constants.cjs

@@ -0,0 +1,232 @@
+'use strict';
+
+/**
+ * Autonomous memory — shared constants.
+ *
+ * Single source of truth for defaults, limits, and magic strings used across
+ * the memory store, tools, flush phase, and tests. Changing a value here
+ * changes it everywhere — no hunting through files.
+ */
+/** Default embedding provider when {@link process.env.MEMORY_EMBEDDINGS_PROVIDER} is unset. */
+const DEFAULT_MEMORY_PROVIDER = 'bedrock';
+/** Default embedding model (Titan v2 — AWS-native, 6× cheaper than Cohere v4). */
+const DEFAULT_MEMORY_MODEL = 'amazon.titan-embed-text-v2:0';
+/** Default vector width (Titan v2 supports 256 / 512 / 1024). */
+const DEFAULT_MEMORY_DIMENSIONS = 1024;
+/** Default Postgres table name; can be overridden via env for dev/prod sharing. */
+const DEFAULT_MEMORY_TABLE = 'agent_memories';
+/** Default Postgres schema. */
+const DEFAULT_MEMORY_SCHEMA = 'public';
+/** Phase values used by the flush-phase gate. */
+const MEMORY_PHASE_NORMAL = 'normal';
+const MEMORY_PHASE_FLUSHING = 'memory_flushing';
+/**
+ * Search defaults — aligned with upstream's upstream defaults.
+ *
+ * Sources:
+ * - `upstream reference` → maxResults=6
+ * - `upstream reference` → maxInjectedChars=4000
+ *
+ * Keeping these in lockstep with upstream means the mandatory-recall tool
+ * description, budget clamps, and eval corpora line up with upstream's
+ * tuning — we inherit their calibration instead of re-tuning from scratch.
+ */
+const DEFAULT_MAX_SEARCH_RESULTS = 6;
+const DEFAULT_MIN_SCORE = 0.1;
+const DEFAULT_MAX_INJECTED_CHARS = 4000;
+/** Hybrid retrieval weights — 70% vector cosine, 30% BM25 / ts_rank text score. */
+const HYBRID_VECTOR_WEIGHT = 0.7;
+const HYBRID_TEXT_WEIGHT = 0.3;
+/**
+ * Phase 2 rerank defaults — ported from upstream.
+ *
+ * Sources:
+ * - `upstream reference` → lambda=0.7
+ * - `upstream reference` → halfLifeDays=30
+ *
+ * Both features are opt-in (enabled=false by default) — the Phase 2
+ * features are layered on top of hybrid search and don't change default
+ * behavior for callers that upgrade in place.
+ */
+const DEFAULT_MMR_ENABLED = false;
+const DEFAULT_MMR_LAMBDA = 0.7;
+const DEFAULT_TEMPORAL_DECAY_ENABLED = false;
+const DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = 30;
+const DEFAULT_RECALL_TRACKING_ENABLED = false;
+const DEFAULT_CITATIONS_MODE = 'auto';
+/**
+ * Flush trigger margins (token counts) — aligned with upstream upstream.
+ *
+ * Sources:
+ * - `upstream reference` → softThreshold=4000
+ * - `upstream reference` → reserveFloor=20000
+ */
+const DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = 4000;
+const DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = 20000;
+/** Hard cap on append calls per flush phase — prevents runaway writes. */
+const DEFAULT_MAX_APPENDS_PER_FLUSH = 20;
+/**
+ * Hard cap on agentic loop iterations inside {@link runMemoryFlush}.
+ *
+ * Each iteration = one model.invoke() followed by execution of any
+ * `memory_append` tool_calls it emits. Mirrors upstream's flush-plan
+ * loop cap; 8 is enough for ~2–3 reflections of batched notes while
+ * protecting against runaway cycles if the model refuses to stop.
+ */
+const DEFAULT_MAX_FLUSH_ITERATIONS = 8;
+/** Path prefix enforced on every append. Paths outside this are rejected. */
+const MEMORY_PATH_PREFIX = 'memory/';
+/** Tool names — kept as constants so server code + tests never drift. */
+const MEMORY_SEARCH_TOOL_NAME = 'memory_search';
+const MEMORY_GET_TOOL_NAME = 'memory_get';
+const MEMORY_APPEND_TOOL_NAME = 'memory_append';
+/**
+ * Mandatory-recall description — the single most load-bearing line in the
+ * whole memory system. Do not soften, shorten, or reword without an eval run.
+ *
+ * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:186`.
+ * The wiki/corpus clause is retained even though Phase 1 doesn't ship
+ * compiled-wiki supplements — keeping the string identical means upstream's
+ * eval corpora remain drop-in valid.
+ */
+const MEMORY_SEARCH_DESCRIPTION = 'Mandatory recall step: semantically search MEMORY.md + memory/*.md ' +
+    '(and optional session transcripts) before answering questions about ' +
+    'prior work, decisions, dates, people, preferences, or todos. Optional ' +
+    '`corpus=wiki` or `corpus=all` also searches registered compiled-wiki ' +
+    'supplements. If response has disabled=true, memory retrieval is ' +
+    'unavailable and should be surfaced to the user.';
+/**
+ * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:322`.
+ */
+const MEMORY_GET_DESCRIPTION = 'Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; ' +
+    '`corpus=wiki` reads from registered compiled-wiki supplements. Use after ' +
+    'search to pull only the needed lines and keep context small.';
+/**
+ * `memory_append` tool description.
+ *
+ * Phase 1 historically wrote to a single date-keyed file
+ * (`memory/YYYY-MM-DD.md`), ported verbatim from upstream. That scheme
+ * is now replaced by an 8-path canonical whitelist — see
+ * {@link ./paths.MEMORY_ALL_PATHS}. The tool description no longer
+ * names a specific file; the flush-turn prompt renders the full rubric
+ * inline so the model sees every writable path at inference time.
+ */
+const MEMORY_APPEND_DESCRIPTION = "Append a durable note to one of the agent's canonical memory documents. " +
+    'The `path` argument MUST be one of the whitelisted paths listed in the ' +
+    'flush prompt rubric — unknown paths are rejected. Content is merged into ' +
+    'the existing row for that document via UPSERT, so the same document ' +
+    'accumulates across sessions.';
+/**
+ * Reply token that signals the flush turn produced no user-visible output.
+ * Ported VERBATIM from upstream `src/auto-reply/tokens.ts:4`.
+ */
+const SILENT_REPLY_TOKEN = 'NO_REPLY';
+/**
+ * Placeholder replaced at flush time with the rendered path-rubric for
+ * the caller's scope. See `renderPathsRubric()` in `./paths.ts` and
+ * `resolveFlushPrompts()` in `../prompts/memoryFlushPrompt.ts`.
+ *
+ * Kept as a unique sentinel so `replaceAll` is safe even if the rubric
+ * content happens to contain regex metacharacters.
+ */
+const FLUSH_PROMPT_RUBRIC_PLACEHOLDER = '{{MEMORY_PATHS_RUBRIC}}';
+/**
+ * Memory-flush prompts — canonical-document model.
+ *
+ * Every durable memory routes into one of 8 stable canonical documents
+ * (4 agent-tier + 4 user-tier). The rubric is injected at flush time so
+ * the model reads the authoritative path list with descriptions, and for
+ * isolated/autonomous agents the user-tier rows are transparently omitted
+ * from the rubric — making "user-tier writes require a scoped caller" a
+ * compile-time guarantee rather than a runtime check alone.
+ *
+ * Two-tier semantics the prompt enforces:
+ *   - **agent/** — shared operational knowledge; every user of this agent
+ *     benefits from rows written here. Do NOT put personal facts here.
+ *   - **user/** — personalization for the specific caller only. Row is
+ *     private to that user; other users never see it.
+ */
+const MEMORY_FLUSH_ROUTING_HINT = 'Route every note into exactly one of the canonical documents below by ' +
+    'picking the best match. Do NOT invent new paths; do NOT create date-keyed ' +
+    'files; unknown paths are rejected by the store.';
+const MEMORY_FLUSH_TIER_HINT = 'Two tiers: `memory/agent/*` is SHARED operational knowledge visible to ' +
+    'every user of this agent — put successful patterns, pitfalls, domain ' +
+    'facts, and house-style there. `memory/user/*` is PRIVATE to the specific ' +
+    'caller — put their identity, preferences, projects, and references there. ' +
+    'Never put user-specific facts in an agent/* document.';
+const MEMORY_FLUSH_READ_ONLY_HINT = 'Treat workspace bootstrap/reference files such as MEMORY.md, DREAMS.md, SOUL.md, TOOLS.md, and AGENTS.md as read-only during this flush; never overwrite, replace, or edit them.';
+/**
+ * Learning hint — steers the flush turn to capture the things that
+ * matter most for future turns: reusable patterns, tool failures
+ * (so the same mistake is not repeated), explicit corrections, and
+ * durable user-specific facts. Append-only via `memory_append`; one
+ * note per lesson.
+ */
+const MEMORY_FLUSH_LEARNING_HINT = 'Capture durable lessons the agent (and future turns) should retain: ' +
+    '(a) successful task patterns and workflows → memory/agent/playbook.md; ' +
+    '(b) tool failures and schema mistakes → memory/agent/pitfalls.md; ' +
+    '(c) stable domain facts about the systems/APIs → memory/agent/domain.md; ' +
+    "(d) this user's preferences, tone, and corrections → memory/user/preferences.md; " +
+    "(e) this user's identity and role → memory/user/profile.md. " +
+    'Write one note per distinct lesson. Do not log conversation summaries ' +
+    'or anything derivable from the code or recent history.';
+const MEMORY_FLUSH_RUBRIC_BLOCK = 'Canonical documents available for this turn (path — tag — description):\n' +
+    FLUSH_PROMPT_RUBRIC_PLACEHOLDER;
+const DEFAULT_MEMORY_FLUSH_PROMPT = [
+    'Pre-compaction memory flush.',
+    MEMORY_FLUSH_ROUTING_HINT,
+    MEMORY_FLUSH_TIER_HINT,
+    MEMORY_FLUSH_READ_ONLY_HINT,
+    MEMORY_FLUSH_LEARNING_HINT,
+    'Call the `memory_append` tool for every note you want to persist, passing one of the whitelisted paths as the `path` argument. Do NOT describe what you are about to write; just call the tool.',
+    `If nothing worth storing, reply with exactly ${SILENT_REPLY_TOKEN}.`,
+    '',
+    MEMORY_FLUSH_RUBRIC_BLOCK,
+].join('\n');
+const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = [
+    'Pre-compaction memory flush turn.',
+    'The session is near auto-compaction; capture durable memories to disk.',
+    MEMORY_FLUSH_ROUTING_HINT,
+    MEMORY_FLUSH_TIER_HINT,
+    MEMORY_FLUSH_READ_ONLY_HINT,
+    MEMORY_FLUSH_LEARNING_HINT,
+    'Use the `memory_append` tool for every durable note, with `path` set to one of the whitelisted canonical documents. Never claim you wrote a note without actually calling the tool.',
+    `If there is nothing worth storing, reply with exactly ${SILENT_REPLY_TOKEN}.`,
+    '',
+    MEMORY_FLUSH_RUBRIC_BLOCK,
+].join('\n');
+
+exports.DEFAULT_CITATIONS_MODE = DEFAULT_CITATIONS_MODE;
+exports.DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS;
+exports.DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS;
+exports.DEFAULT_MAX_APPENDS_PER_FLUSH = DEFAULT_MAX_APPENDS_PER_FLUSH;
+exports.DEFAULT_MAX_FLUSH_ITERATIONS = DEFAULT_MAX_FLUSH_ITERATIONS;
+exports.DEFAULT_MAX_INJECTED_CHARS = DEFAULT_MAX_INJECTED_CHARS;
+exports.DEFAULT_MAX_SEARCH_RESULTS = DEFAULT_MAX_SEARCH_RESULTS;
+exports.DEFAULT_MEMORY_DIMENSIONS = DEFAULT_MEMORY_DIMENSIONS;
+exports.DEFAULT_MEMORY_FLUSH_PROMPT = DEFAULT_MEMORY_FLUSH_PROMPT;
+exports.DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT;
+exports.DEFAULT_MEMORY_MODEL = DEFAULT_MEMORY_MODEL;
+exports.DEFAULT_MEMORY_PROVIDER = DEFAULT_MEMORY_PROVIDER;
+exports.DEFAULT_MEMORY_SCHEMA = DEFAULT_MEMORY_SCHEMA;
+exports.DEFAULT_MEMORY_TABLE = DEFAULT_MEMORY_TABLE;
+exports.DEFAULT_MIN_SCORE = DEFAULT_MIN_SCORE;
+exports.DEFAULT_MMR_ENABLED = DEFAULT_MMR_ENABLED;
+exports.DEFAULT_MMR_LAMBDA = DEFAULT_MMR_LAMBDA;
+exports.DEFAULT_RECALL_TRACKING_ENABLED = DEFAULT_RECALL_TRACKING_ENABLED;
+exports.DEFAULT_TEMPORAL_DECAY_ENABLED = DEFAULT_TEMPORAL_DECAY_ENABLED;
+exports.DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS;
+exports.FLUSH_PROMPT_RUBRIC_PLACEHOLDER = FLUSH_PROMPT_RUBRIC_PLACEHOLDER;
+exports.HYBRID_TEXT_WEIGHT = HYBRID_TEXT_WEIGHT;
+exports.HYBRID_VECTOR_WEIGHT = HYBRID_VECTOR_WEIGHT;
+exports.MEMORY_APPEND_DESCRIPTION = MEMORY_APPEND_DESCRIPTION;
+exports.MEMORY_APPEND_TOOL_NAME = MEMORY_APPEND_TOOL_NAME;
+exports.MEMORY_GET_DESCRIPTION = MEMORY_GET_DESCRIPTION;
+exports.MEMORY_GET_TOOL_NAME = MEMORY_GET_TOOL_NAME;
+exports.MEMORY_PATH_PREFIX = MEMORY_PATH_PREFIX;
+exports.MEMORY_PHASE_FLUSHING = MEMORY_PHASE_FLUSHING;
+exports.MEMORY_PHASE_NORMAL = MEMORY_PHASE_NORMAL;
+exports.MEMORY_SEARCH_DESCRIPTION = MEMORY_SEARCH_DESCRIPTION;
+exports.MEMORY_SEARCH_TOOL_NAME = MEMORY_SEARCH_TOOL_NAME;
+exports.SILENT_REPLY_TOKEN = SILENT_REPLY_TOKEN;
+//# sourceMappingURL=constants.cjs.map

package/dist/cjs/memory/constants.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","sources":["../../../src/memory/constants.ts"],"sourcesContent":["/**\n * Autonomous memory — shared constants.\n *\n * Single source of truth for defaults, limits, and magic strings used across\n * the memory store, tools, flush phase, and tests. Changing a value here\n * changes it everywhere — no hunting through files.\n */\n\n/** Default embedding provider when {@link process.env.MEMORY_EMBEDDINGS_PROVIDER} is unset. */\nexport const DEFAULT_MEMORY_PROVIDER = 'bedrock' as const;\n\n/** Default embedding model (Titan v2 — AWS-native, 6× cheaper than Cohere v4). */\nexport const DEFAULT_MEMORY_MODEL = 'amazon.titan-embed-text-v2:0';\n\n/** Default vector width (Titan v2 supports 256 / 512 / 1024). */\nexport const DEFAULT_MEMORY_DIMENSIONS = 1024;\n\n/** Default Postgres table name; can be overridden via env for dev/prod sharing. */\nexport const DEFAULT_MEMORY_TABLE = 'agent_memories';\n\n/** Default Postgres schema. */\nexport const DEFAULT_MEMORY_SCHEMA = 'public';\n\n/** Phase values used by the flush-phase gate. */\nexport const MEMORY_PHASE_NORMAL = 'normal';\nexport const MEMORY_PHASE_FLUSHING = 'memory_flushing';\n\n/**\n * Search defaults — aligned with upstream's upstream defaults.\n *\n * Sources:\n * - `upstream reference` → maxResults=6\n * - `upstream reference` → maxInjectedChars=4000\n *\n * Keeping these in lockstep with upstream means the mandatory-recall tool\n * description, budget clamps, and eval corpora line up with upstream's\n * tuning — we inherit their calibration instead of re-tuning from scratch.\n */\nexport const DEFAULT_MAX_SEARCH_RESULTS = 6;\nexport const DEFAULT_MIN_SCORE = 0.1;\nexport const DEFAULT_MAX_INJECTED_CHARS = 4000;\n\n/** Hybrid retrieval weights — 70% vector cosine, 30% BM25 / ts_rank text score. */\nexport const HYBRID_VECTOR_WEIGHT = 0.7;\nexport const HYBRID_TEXT_WEIGHT = 0.3;\n\n/**\n * Phase 2 rerank defaults — ported from upstream.\n *\n * Sources:\n * - `upstream reference` → lambda=0.7\n * - `upstream reference` → halfLifeDays=30\n *\n * Both features are opt-in (enabled=false by default) — the Phase 2\n * features are layered on top of hybrid search and don't change default\n * behavior for callers that upgrade in place.\n */\nexport const DEFAULT_MMR_ENABLED = false;\nexport const DEFAULT_MMR_LAMBDA = 0.7;\nexport const DEFAULT_TEMPORAL_DECAY_ENABLED = false;\nexport const DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = 30;\nexport const DEFAULT_RECALL_TRACKING_ENABLED = false;\nexport const DEFAULT_CITATIONS_MODE = 'auto' as const;\n\n/**\n * Flush trigger margins (token counts) — aligned with upstream upstream.\n *\n * Sources:\n * - `upstream reference` → softThreshold=4000\n * - `upstream reference` → reserveFloor=20000\n */\nexport const DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = 4000;\nexport const DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = 20000;\n\n/** Hard cap on append calls per flush phase — prevents runaway writes. */\nexport const DEFAULT_MAX_APPENDS_PER_FLUSH = 20;\n\n/**\n * Hard cap on agentic loop iterations inside {@link runMemoryFlush}.\n *\n * Each iteration = one model.invoke() followed by execution of any\n * `memory_append` tool_calls it emits. Mirrors upstream's flush-plan\n * loop cap; 8 is enough for ~2–3 reflections of batched notes while\n * protecting against runaway cycles if the model refuses to stop.\n */\nexport const DEFAULT_MAX_FLUSH_ITERATIONS = 8;\n\n/** Path prefix enforced on every append. Paths outside this are rejected. */\nexport const MEMORY_PATH_PREFIX = 'memory/';\n\n/** Tool names — kept as constants so server code + tests never drift. */\nexport const MEMORY_SEARCH_TOOL_NAME = 'memory_search';\nexport const MEMORY_GET_TOOL_NAME = 'memory_get';\nexport const MEMORY_APPEND_TOOL_NAME = 'memory_append';\n\n/**\n * Mandatory-recall description — the single most load-bearing line in the\n * whole memory system. Do not soften, shorten, or reword without an eval run.\n *\n * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:186`.\n * The wiki/corpus clause is retained even though Phase 1 doesn't ship\n * compiled-wiki supplements — keeping the string identical means upstream's\n * eval corpora remain drop-in valid.\n */\nexport const MEMORY_SEARCH_DESCRIPTION =\n  'Mandatory recall step: semantically search MEMORY.md + memory/*.md ' +\n  '(and optional session transcripts) before answering questions about ' +\n  'prior work, decisions, dates, people, preferences, or todos. Optional ' +\n  '`corpus=wiki` or `corpus=all` also searches registered compiled-wiki ' +\n  'supplements. If response has disabled=true, memory retrieval is ' +\n  'unavailable and should be surfaced to the user.';\n\n/**\n * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:322`.\n */\nexport const MEMORY_GET_DESCRIPTION =\n  'Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; ' +\n  '`corpus=wiki` reads from registered compiled-wiki supplements. Use after ' +\n  'search to pull only the needed lines and keep context small.';\n\n/**\n * `memory_append` tool description.\n *\n * Phase 1 historically wrote to a single date-keyed file\n * (`memory/YYYY-MM-DD.md`), ported verbatim from upstream. That scheme\n * is now replaced by an 8-path canonical whitelist — see\n * {@link ./paths.MEMORY_ALL_PATHS}. The tool description no longer\n * names a specific file; the flush-turn prompt renders the full rubric\n * inline so the model sees every writable path at inference time.\n */\nexport const MEMORY_APPEND_DESCRIPTION =\n  \"Append a durable note to one of the agent's canonical memory documents. \" +\n  'The `path` argument MUST be one of the whitelisted paths listed in the ' +\n  'flush prompt rubric — unknown paths are rejected. Content is merged into ' +\n  'the existing row for that document via UPSERT, so the same document ' +\n  'accumulates across sessions.';\n\n/**\n * Reply token that signals the flush turn produced no user-visible output.\n * Ported VERBATIM from upstream `src/auto-reply/tokens.ts:4`.\n */\nexport const SILENT_REPLY_TOKEN = 'NO_REPLY';\n\n/**\n * Placeholder replaced at flush time with the rendered path-rubric for\n * the caller's scope. See `renderPathsRubric()` in `./paths.ts` and\n * `resolveFlushPrompts()` in `../prompts/memoryFlushPrompt.ts`.\n *\n * Kept as a unique sentinel so `replaceAll` is safe even if the rubric\n * content happens to contain regex metacharacters.\n */\nexport const FLUSH_PROMPT_RUBRIC_PLACEHOLDER = '{{MEMORY_PATHS_RUBRIC}}';\n\n/**\n * Memory-flush prompts — canonical-document model.\n *\n * Every durable memory routes into one of 8 stable canonical documents\n * (4 agent-tier + 4 user-tier). The rubric is injected at flush time so\n * the model reads the authoritative path list with descriptions, and for\n * isolated/autonomous agents the user-tier rows are transparently omitted\n * from the rubric — making \"user-tier writes require a scoped caller\" a\n * compile-time guarantee rather than a runtime check alone.\n *\n * Two-tier semantics the prompt enforces:\n *   - **agent/** — shared operational knowledge; every user of this agent\n *     benefits from rows written here. Do NOT put personal facts here.\n *   - **user/** — personalization for the specific caller only. Row is\n *     private to that user; other users never see it.\n */\nconst MEMORY_FLUSH_ROUTING_HINT =\n  'Route every note into exactly one of the canonical documents below by ' +\n  'picking the best match. Do NOT invent new paths; do NOT create date-keyed ' +\n  'files; unknown paths are rejected by the store.';\n\nconst MEMORY_FLUSH_TIER_HINT =\n  'Two tiers: `memory/agent/*` is SHARED operational knowledge visible to ' +\n  'every user of this agent — put successful patterns, pitfalls, domain ' +\n  'facts, and house-style there. `memory/user/*` is PRIVATE to the specific ' +\n  'caller — put their identity, preferences, projects, and references there. ' +\n  'Never put user-specific facts in an agent/* document.';\n\nconst MEMORY_FLUSH_READ_ONLY_HINT =\n  'Treat workspace bootstrap/reference files such as MEMORY.md, DREAMS.md, SOUL.md, TOOLS.md, and AGENTS.md as read-only during this flush; never overwrite, replace, or edit them.';\n\n/**\n * Learning hint — steers the flush turn to capture the things that\n * matter most for future turns: reusable patterns, tool failures\n * (so the same mistake is not repeated), explicit corrections, and\n * durable user-specific facts. Append-only via `memory_append`; one\n * note per lesson.\n */\nconst MEMORY_FLUSH_LEARNING_HINT =\n  'Capture durable lessons the agent (and future turns) should retain: ' +\n  '(a) successful task patterns and workflows → memory/agent/playbook.md; ' +\n  '(b) tool failures and schema mistakes → memory/agent/pitfalls.md; ' +\n  '(c) stable domain facts about the systems/APIs → memory/agent/domain.md; ' +\n  \"(d) this user's preferences, tone, and corrections → memory/user/preferences.md; \" +\n  \"(e) this user's identity and role → memory/user/profile.md. \" +\n  'Write one note per distinct lesson. Do not log conversation summaries ' +\n  'or anything derivable from the code or recent history.';\n\nconst MEMORY_FLUSH_RUBRIC_BLOCK =\n  'Canonical documents available for this turn (path — tag — description):\\n' +\n  FLUSH_PROMPT_RUBRIC_PLACEHOLDER;\n\nexport const DEFAULT_MEMORY_FLUSH_PROMPT = [\n  'Pre-compaction memory flush.',\n  MEMORY_FLUSH_ROUTING_HINT,\n  MEMORY_FLUSH_TIER_HINT,\n  MEMORY_FLUSH_READ_ONLY_HINT,\n  MEMORY_FLUSH_LEARNING_HINT,\n  'Call the `memory_append` tool for every note you want to persist, passing one of the whitelisted paths as the `path` argument. Do NOT describe what you are about to write; just call the tool.',\n  `If nothing worth storing, reply with exactly ${SILENT_REPLY_TOKEN}.`,\n  '',\n  MEMORY_FLUSH_RUBRIC_BLOCK,\n].join('\\n');\n\nexport const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = [\n  'Pre-compaction memory flush turn.',\n  'The session is near auto-compaction; capture durable memories to disk.',\n  MEMORY_FLUSH_ROUTING_HINT,\n  MEMORY_FLUSH_TIER_HINT,\n  MEMORY_FLUSH_READ_ONLY_HINT,\n  MEMORY_FLUSH_LEARNING_HINT,\n  'Use the `memory_append` tool for every durable note, with `path` set to one of the whitelisted canonical documents. Never claim you wrote a note without actually calling the tool.',\n  `If there is nothing worth storing, reply with exactly ${SILENT_REPLY_TOKEN}.`,\n  '',\n  MEMORY_FLUSH_RUBRIC_BLOCK,\n].join('\\n');\n"],"names":[],"mappings":";;AAAA;;;;;;AAMG;AAEH;AACO,MAAM,uBAAuB,GAAG;AAEvC;AACO,MAAM,oBAAoB,GAAG;AAEpC;AACO,MAAM,yBAAyB,GAAG;AAEzC;AACO,MAAM,oBAAoB,GAAG;AAEpC;AACO,MAAM,qBAAqB,GAAG;AAErC;AACO,MAAM,mBAAmB,GAAG;AAC5B,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;AAUG;AACI,MAAM,0BAA0B,GAAG;AACnC,MAAM,iBAAiB,GAAG;AAC1B,MAAM,0BAA0B,GAAG;AAE1C;AACO,MAAM,oBAAoB,GAAG;AAC7B,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;AAUG;AACI,MAAM,mBAAmB,GAAG;AAC5B,MAAM,kBAAkB,GAAG;AAC3B,MAAM,8BAA8B,GAAG;AACvC,MAAM,qCAAqC,GAAG;AAC9C,MAAM,+BAA+B,GAAG;AACxC,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,mCAAmC,GAAG;AAC5C,MAAM,kCAAkC,GAAG;AAElD;AACO,MAAM,6BAA6B,GAAG;AAE7C;;;;;;;AAOG;AACI,MAAM,4BAA4B,GAAG;AAE5C;AACO,MAAM,kBAAkB,GAAG;AAElC;AACO,MAAM,uBAAuB,GAAG;AAChC,MAAM,oBAAoB,GAAG;AAC7B,MAAM,uBAAuB,GAAG;AAEvC;;;;;;;;AAQG;AACI,MAAM,yBAAyB,GACpC,qEAAqE;IACrE,sEAAsE;IACtE,wEAAwE;IACxE,uEAAuE;IACvE,kEAAkE;AAClE,IAAA;AAEF;;AAEG;AACI,MAAM,sBAAsB,GACjC,4EAA4E;IAC5E,2EAA2E;AAC3E,IAAA;AAEF;;;;;;;;;AASG;AACI,MAAM,yBAAyB,GACpC,0EAA0E;IAC1E,yEAAyE;IACzE,2EAA2E;IAC3E,sEAAsE;AACtE,IAAA;AAEF;;;AAGG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;AAOG;AACI,MAAM,+BAA+B,GAAG;AAE/C;;;;;;;;;;;;;;;AAeG;AACH,MAAM,yBAAyB,GAC7B,wEAAwE;IACxE,4EAA4E;AAC5E,IAAA,iDAAiD;AAEnD,MAAM,sBAAsB,GAC1B,yEAAyE;IACzE,uEAAuE;IACvE,2EAA2E;IAC3E,4EAA4E;AAC5E,IAAA,uDAAuD;AAEzD,MAAM,2BAA2B,GAC/B,kLAAkL;AAEpL;;;;;;AAMG;AACH,MAAM,0BAA0B,GAC9B,sEAAsE;IACtE,yEAAyE;IACzE,oEAAoE;IACpE,2EAA2E;IAC3E,mFAAmF;IACnF,8DAA8D;IAC9D,wEAAwE;AACxE,IAAA,wDAAwD;AAE1D,MAAM,yBAAyB,GAC7B,2EAA2E;AAC3E,IAAA,+BAA+B;AAE1B,MAAM,2BAA2B,GAAG;IACzC,8BAA8B;IAC9B,yBAAyB;IACzB,sBAAsB;IACtB,2BAA2B;IAC3B,0BAA0B;IAC1B,iMAAiM;AACjM,IAAA,CAAA,6CAAA,EAAgD,kBAAkB,CAAA,CAAA,CAAG;IACrE,EAAE;IACF,yBAAyB;AAC1B,CAAA,CAAC,IAAI,CAAC,IAAI;AAEJ,MAAM,kCAAkC,GAAG;IAChD,mCAAmC;IACnC,wEAAwE;IACxE,yBAAyB;IACzB,sBAAsB;IACtB,2BAA2B;IAC3B,0BAA0B;IAC1B,qLAAqL;AACrL,IAAA,CAAA,sDAAA,EAAyD,kBAAkB,CAAA,CAAA,CAAG;IAC9E,EAAE;IACF,yBAAyB;AAC1B,CAAA,CAAC,IAAI,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}