@smyslenny/agent-memory 5.0.2 → 5.1.0

package/dist/index.d.ts

@@ -72,6 +72,46 @@ declare function createMemory(db: Database.Database, input: CreateMemoryInput):
 declare function getMemory(db: Database.Database, id: string): Memory | null;
 declare function updateMemory(db: Database.Database, id: string, input: UpdateMemoryInput): Memory | null;
 declare function deleteMemory(db: Database.Database, id: string): boolean;
+interface ArchivedMemory {
+    id: string;
+    content: string;
+    type: string;
+    priority: number;
+    emotion_val: number;
+    vitality: number;
+    stability: number;
+    access_count: number;
+    last_accessed: string | null;
+    created_at: string;
+    updated_at: string;
+    archived_at: string;
+    archive_reason: string;
+    source: string | null;
+    agent_id: string;
+    hash: string | null;
+    emotion_tag: string | null;
+    source_session: string | null;
+    source_context: string | null;
+    observed_at: string | null;
+}
+/**
+ * Archive a memory to memory_archive, then delete from memories.
+ * If minVitality is set (default 0.1), memories below that threshold
+ * are directly deleted without archiving — they're decayed noise.
+ * Returns "archived" if actually archived, "deleted" if skipped to direct delete,
+ * or false if memory not found.
+ */
+declare function archiveMemory(db: Database.Database, id: string, reason?: string, opts?: {
+    minVitality?: number;
+}): "archived" | "deleted" | false;
+declare function restoreMemory(db: Database.Database, id: string): Memory | null;
+declare function listArchivedMemories(db: Database.Database, opts?: {
+    agent_id?: string;
+    limit?: number;
+}): ArchivedMemory[];
+declare function purgeArchive(db: Database.Database, opts?: {
+    agent_id?: string;
+}): number;
 declare function listMemories(db: Database.Database, opts?: {
     agent_id?: string;
     type?: MemoryType;
@@ -517,6 +557,10 @@ interface ReflectInput {
 }
 declare function reflectMemories(db: Database.Database, input: ReflectInput): Promise<ReflectRunResult>;
 
+interface CapacityInfo {
+    count: number;
+    limit: number | null;
+}
 interface StatusResult {
     total: number;
     by_type: Record<string, number>;
@@ -525,6 +569,7 @@ interface StatusResult {
     low_vitality: number;
     feedback_events: number;
     agent_id: string;
+    capacity: Record<string, CapacityInfo>;
 }
 declare function getMemoryStatus(db: Database.Database, input?: {
     agent_id?: string;
@@ -764,6 +809,8 @@ interface GovernResult {
     orphanPaths: number;
     emptyMemories: number;
     evicted: number;
+    archived: number;
+    evictedByType: Record<string, number>;
 }
 interface EvictionCandidate {
     memory: Memory;
@@ -783,13 +830,28 @@ declare function computeEvictionScore(input: {
 declare function rankEvictionCandidates(db: Database.Database, opts?: {
     agent_id?: string;
 }): EvictionCandidate[];
+interface TieredCapacity {
+    identity: number | null;
+    emotion: number | null;
+    knowledge: number | null;
+    event: number | null;
+    total: number;
+}
+declare function getTieredCapacity(opts?: {
+    maxMemories?: number;
+}): TieredCapacity;
 /**
  * Run governance checks and cleanup:
  * 1. Remove orphan paths (no parent memory)
  * 2. Remove empty memories (blank content)
- * 3. Evict low-value memories when over capacity using eviction_score
+ * 3. Evict low-value memories when over capacity using tiered + global eviction
+ *
+ * Tiered capacity can be set via env vars:
+ *   AGENT_MEMORY_MAX_IDENTITY, AGENT_MEMORY_MAX_EMOTION,
+ *   AGENT_MEMORY_MAX_KNOWLEDGE, AGENT_MEMORY_MAX_EVENT,
+ *   AGENT_MEMORY_MAX_MEMORIES (global cap, default 350)
  *
- * maxMemories can be set via AGENT_MEMORY_MAX_MEMORIES env var (default: 200).
+ * Evicted memories are archived to memory_archive before deletion.
  */
 declare function runGovern(db: Database.Database, opts?: {
     agent_id?: string;
@@ -843,4 +905,4 @@ declare function formatNarrativeBoot(layers: {
  */
 declare function boot(db: Database.Database, opts?: WarmBootOptions): WarmBootResult;
 
-export { type AgentMemoryHttpServer, type ReflectInput as AppReflectInput, type ReflectProgressEvent as AppReflectProgressEvent, type AutoIngestWatcher, type AutoIngestWatcherOptions, type BootResult, type ConflictInfo, type ConflictType, type CreateMemoryInput, type DedupScoreBreakdown, type EmbeddingProvider, type EmbeddingProviderConfig, type EmbeddingProviderKind, type EmbeddingProviderOptions, type EmbeddingStatus, type EvictionCandidate, type ExportResult, type FeedbackEventInput, type FeedbackEventRecord, type FeedbackSource, type FeedbackSummary, type GovernResult, type GuardAction, type GuardInput, type GuardResult, type HttpJobStatus, type HttpServerOptions, type HybridRecallResponse, type HybridRecallResult, type IngestExtractedItem, type IngestResult, type IngestRunOptions, type MaintenanceJob, type MaintenancePhase, type MaintenanceStatus, type Memory, type MemoryType, type MergeContext, type MergePlan, type Path, type PendingEmbeddingRecord, type Priority, type RecallInput, type ReflectCheckpoint, type ReflectOptions, type ReflectProgressEvent$1 as ReflectProgressEvent, type ReflectRunResult, type ReflectRunners, type ReflectStats, type ReflectStep, type ReindexEmbeddingsResult, type ReindexInput, type ReindexProgressEvent, type ReindexSearchResult, type RelatedLink, type RememberInput, type SearchResult, type StatusResult, type StoredEmbedding, type SurfaceInput, type SurfaceIntent, type SurfaceResponse, type SurfaceResult, type SyncInput, type SyncResult, type TidyResult, type UpdateMemoryInput, type VectorSearchResult, type WarmBootOptions, type WarmBootResult, boot, buildFtsQuery, buildMergePlan, calculateVitality, classifyIngestType, completeMaintenanceJob, computeEvictionScore, contentHash, cosineSimilarity, countMemories, createEmbeddingProvider, createHttpServer, createInitialCheckpoint, createLocalHttpEmbeddingProvider, createMaintenanceJob, createMemory, createOpenAICompatibleEmbeddingProvider, createPath, decodeVector, deleteMemory, deletePath, encodeVector, exportMemories, extractIngestItems, failMaintenanceJob, fetchRelatedLinks, findResumableMaintenanceJob, formatNarrativeBoot, formatRelativeDate, fuseHybridResults, fusionScore, getConfiguredEmbeddingProviderId, getDecayedMemories, getEmbedding, getEmbeddingProvider, getEmbeddingProviderConfigFromEnv, getEmbeddingProviderFromEnv, getFeedbackScore, getFeedbackSummary, getMaintenanceJob, getMemory, getMemoryStatus, getPath, getPathByUri, getPathsByDomain, getPathsByMemory, getPathsByPrefix, guard, healthcheckEmbeddingProvider, ingestText, isStaleContent, listMemories, listPendingEmbeddings, loadWarmBootLayers, markAllEmbeddingsPending, markEmbeddingFailed, markMemoryEmbeddingPending, parseUri, priorityPrior, rankEvictionCandidates, rebuildBm25Index, recallMemories, recallMemory, recordAccess, recordFeedbackEvent, recordPassiveFeedback, reflectMemories, reindexEmbeddings, reindexMemories, reindexMemorySearch, rememberMemory, runAutoIngestWatcher, runDecay, runGovern, runReflectOrchestrator, runTidy, searchBM25, searchByVector, slugify, splitIngestBlocks, startHttpServer, surfaceMemories, syncBatch, syncOne, tokenize, updateMaintenanceCheckpoint, updateMemory, upsertReadyEmbedding };
+export { type AgentMemoryHttpServer, type ReflectInput as AppReflectInput, type ReflectProgressEvent as AppReflectProgressEvent, type ArchivedMemory, type AutoIngestWatcher, type AutoIngestWatcherOptions, type BootResult, type CapacityInfo, type ConflictInfo, type ConflictType, type CreateMemoryInput, type DedupScoreBreakdown, type EmbeddingProvider, type EmbeddingProviderConfig, type EmbeddingProviderKind, type EmbeddingProviderOptions, type EmbeddingStatus, type EvictionCandidate, type ExportResult, type FeedbackEventInput, type FeedbackEventRecord, type FeedbackSource, type FeedbackSummary, type GovernResult, type GuardAction, type GuardInput, type GuardResult, type HttpJobStatus, type HttpServerOptions, type HybridRecallResponse, type HybridRecallResult, type IngestExtractedItem, type IngestResult, type IngestRunOptions, type MaintenanceJob, type MaintenancePhase, type MaintenanceStatus, type Memory, type MemoryType, type MergeContext, type MergePlan, type Path, type PendingEmbeddingRecord, type Priority, type RecallInput, type ReflectCheckpoint, type ReflectOptions, type ReflectProgressEvent$1 as ReflectProgressEvent, type ReflectRunResult, type ReflectRunners, type ReflectStats, type ReflectStep, type ReindexEmbeddingsResult, type ReindexInput, type ReindexProgressEvent, type ReindexSearchResult, type RelatedLink, type RememberInput, type SearchResult, type StatusResult, type StoredEmbedding, type SurfaceInput, type SurfaceIntent, type SurfaceResponse, type SurfaceResult, type SyncInput, type SyncResult, type TidyResult, type TieredCapacity, type UpdateMemoryInput, type VectorSearchResult, type WarmBootOptions, type WarmBootResult, archiveMemory, boot, buildFtsQuery, buildMergePlan, calculateVitality, classifyIngestType, completeMaintenanceJob, computeEvictionScore, contentHash, cosineSimilarity, countMemories, createEmbeddingProvider, createHttpServer, createInitialCheckpoint, createLocalHttpEmbeddingProvider, createMaintenanceJob, createMemory, createOpenAICompatibleEmbeddingProvider, createPath, decodeVector, deleteMemory, deletePath, encodeVector, exportMemories, extractIngestItems, failMaintenanceJob, fetchRelatedLinks, findResumableMaintenanceJob, formatNarrativeBoot, formatRelativeDate, fuseHybridResults, fusionScore, getConfiguredEmbeddingProviderId, getDecayedMemories, getEmbedding, getEmbeddingProvider, getEmbeddingProviderConfigFromEnv, getEmbeddingProviderFromEnv, getFeedbackScore, getFeedbackSummary, getMaintenanceJob, getMemory, getMemoryStatus, getPath, getPathByUri, getPathsByDomain, getPathsByMemory, getPathsByPrefix, getTieredCapacity, guard, healthcheckEmbeddingProvider, ingestText, isStaleContent, listArchivedMemories, listMemories, listPendingEmbeddings, loadWarmBootLayers, markAllEmbeddingsPending, markEmbeddingFailed, markMemoryEmbeddingPending, parseUri, priorityPrior, purgeArchive, rankEvictionCandidates, rebuildBm25Index, recallMemories, recallMemory, recordAccess, recordFeedbackEvent, recordPassiveFeedback, reflectMemories, reindexEmbeddings, reindexMemories, reindexMemorySearch, rememberMemory, restoreMemory, runAutoIngestWatcher, runDecay, runGovern, runReflectOrchestrator, runTidy, searchBM25, searchByVector, slugify, splitIngestBlocks, startHttpServer, surfaceMemories, syncBatch, syncOne, tokenize, updateMaintenanceCheckpoint, updateMemory, upsertReadyEmbedding };

package/dist/index.js

@@ -6,7 +6,7 @@ import { createHash as createHash2 } from "crypto";
 // src/core/db.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
-var SCHEMA_VERSION = 7;
+var SCHEMA_VERSION = 8;
 var SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -112,6 +112,30 @@ CREATE TABLE IF NOT EXISTS schema_meta (
   value TEXT NOT NULL
 );
 
+-- Memory archive (eviction archive)
+CREATE TABLE IF NOT EXISTS memory_archive (
+  id             TEXT PRIMARY KEY,
+  content        TEXT NOT NULL,
+  type           TEXT NOT NULL,
+  priority       INTEGER NOT NULL,
+  emotion_val    REAL NOT NULL DEFAULT 0.0,
+  vitality       REAL NOT NULL DEFAULT 0.0,
+  stability      REAL NOT NULL DEFAULT 1.0,
+  access_count   INTEGER NOT NULL DEFAULT 0,
+  last_accessed  TEXT,
+  created_at     TEXT NOT NULL,
+  updated_at     TEXT NOT NULL,
+  archived_at    TEXT NOT NULL,
+  archive_reason TEXT NOT NULL DEFAULT 'eviction',
+  source         TEXT,
+  agent_id       TEXT NOT NULL DEFAULT 'default',
+  hash           TEXT,
+  emotion_tag    TEXT,
+  source_session TEXT,
+  source_context TEXT,
+  observed_at    TEXT
+);
+
 -- Indexes for common queries
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_priority ON memories(priority);
@@ -122,6 +146,9 @@ CREATE INDEX IF NOT EXISTS idx_paths_memory ON paths(memory_id);
 CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_phase_status ON maintenance_jobs(phase, status, started_at DESC);
 CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);
 `;
 function isCountRow(row) {
   return row !== null && typeof row === "object" && "c" in row && typeof row.c === "number";
@@ -213,6 +240,11 @@ function migrateDatabase(db, from, to) {
       v = 7;
       continue;
     }
+    if (v === 7) {
+      migrateV7ToV8(db);
+      v = 8;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -300,6 +332,8 @@ function inferSchemaVersion(db) {
   const hasFeedbackEvents = tableExists(db, "feedback_events");
   const hasEmotionTag = tableHasColumn(db, "memories", "emotion_tag");
   const hasProvenance = tableHasColumn(db, "memories", "source_session") && tableHasColumn(db, "memories", "source_context") && tableHasColumn(db, "memories", "observed_at");
+  const hasMemoryArchive = tableExists(db, "memory_archive");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag && hasProvenance && hasMemoryArchive) return 8;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag && hasProvenance) return 7;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag) return 6;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
@@ -341,6 +375,11 @@ function ensureIndexes(db) {
       db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
     }
   }
+  if (tableExists(db, "memory_archive")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);");
+  }
 }
 function ensureFeedbackEventSchema(db) {
   if (!tableExists(db, "feedback_events")) return;
@@ -516,6 +555,50 @@ function migrateV6ToV7(db) {
     throw e;
   }
 }
+function migrateV7ToV8(db) {
+  if (tableExists(db, "memory_archive")) {
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(8));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_archive (
+        id             TEXT PRIMARY KEY,
+        content        TEXT NOT NULL,
+        type           TEXT NOT NULL,
+        priority       INTEGER NOT NULL,
+        emotion_val    REAL NOT NULL DEFAULT 0.0,
+        vitality       REAL NOT NULL DEFAULT 0.0,
+        stability      REAL NOT NULL DEFAULT 1.0,
+        access_count   INTEGER NOT NULL DEFAULT 0,
+        last_accessed  TEXT,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL,
+        archived_at    TEXT NOT NULL,
+        archive_reason TEXT NOT NULL DEFAULT 'eviction',
+        source         TEXT,
+        agent_id       TEXT NOT NULL DEFAULT 'default',
+        hash           TEXT,
+        emotion_tag    TEXT,
+        source_session TEXT,
+        source_context TEXT,
+        observed_at    TEXT
+      );
+    `);
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);");
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(8));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 
 // src/search/tokenizer.ts
 import { readFileSync } from "fs";
@@ -1169,9 +1252,118 @@ function updateMemory(db, id, input) {
 }
 function deleteMemory(db, id) {
   db.prepare("DELETE FROM memories_fts WHERE id = ?").run(id);
+  try {
+    db.prepare("DELETE FROM embeddings WHERE memory_id = ?").run(id);
+  } catch {
+  }
   const result = db.prepare("DELETE FROM memories WHERE id = ?").run(id);
   return result.changes > 0;
 }
+function archiveMemory(db, id, reason, opts) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  const minVitality = opts?.minVitality ?? 0.1;
+  if (mem.vitality < minVitality) {
+    deleteMemory(db, id);
+    return "deleted";
+  }
+  const archivedAt = now();
+  const archiveReason = reason ?? "eviction";
+  db.prepare(
+    `INSERT OR REPLACE INTO memory_archive
+     (id, content, type, priority, emotion_val, vitality, stability, access_count,
+      last_accessed, created_at, updated_at, archived_at, archive_reason,
+      source, agent_id, hash, emotion_tag, source_session, source_context, observed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    mem.id,
+    mem.content,
+    mem.type,
+    mem.priority,
+    mem.emotion_val,
+    mem.vitality,
+    mem.stability,
+    mem.access_count,
+    mem.last_accessed,
+    mem.created_at,
+    mem.updated_at,
+    archivedAt,
+    archiveReason,
+    mem.source,
+    mem.agent_id,
+    mem.hash,
+    mem.emotion_tag,
+    mem.source_session,
+    mem.source_context,
+    mem.observed_at
+  );
+  deleteMemory(db, id);
+  return "archived";
+}
+function restoreMemory(db, id) {
+  const archived = db.prepare("SELECT * FROM memory_archive WHERE id = ?").get(id);
+  if (!archived) return null;
+  db.prepare(
+    `INSERT INTO memories
+     (id, content, type, priority, emotion_val, vitality, stability, access_count,
+      last_accessed, created_at, updated_at, source, agent_id, hash, emotion_tag,
+      source_session, source_context, observed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    archived.id,
+    archived.content,
+    archived.type,
+    archived.priority,
+    archived.emotion_val,
+    archived.vitality,
+    archived.stability,
+    archived.access_count,
+    archived.last_accessed,
+    archived.created_at,
+    now(),
+    // updated_at = restore time
+    archived.source,
+    archived.agent_id,
+    archived.hash,
+    archived.emotion_tag,
+    archived.source_session,
+    archived.source_context,
+    archived.observed_at
+  );
+  db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(
+    archived.id,
+    tokenizeForIndex(archived.content)
+  );
+  if (archived.hash) {
+    const providerId = getConfiguredEmbeddingProviderId();
+    if (providerId) {
+      try {
+        markMemoryEmbeddingPending(db, archived.id, providerId, archived.hash);
+      } catch {
+      }
+    }
+  }
+  db.prepare("DELETE FROM memory_archive WHERE id = ?").run(id);
+  return getMemory(db, archived.id);
+}
+function listArchivedMemories(db, opts) {
+  const agentId = opts?.agent_id;
+  const limit = opts?.limit ?? 20;
+  if (agentId) {
+    return db.prepare(
+      "SELECT * FROM memory_archive WHERE agent_id = ? ORDER BY archived_at DESC LIMIT ?"
+    ).all(agentId, limit);
+  }
+  return db.prepare(
+    "SELECT * FROM memory_archive ORDER BY archived_at DESC LIMIT ?"
+  ).all(limit);
+}
+function purgeArchive(db, opts) {
+  if (opts?.agent_id) {
+    return db.prepare("DELETE FROM memory_archive WHERE agent_id = ?").run(opts.agent_id).changes;
+  }
+  return db.prepare("DELETE FROM memory_archive").run().changes;
+}
 function listMemories(db, opts) {
   const conditions = [];
   const params = [];
@@ -2775,13 +2967,31 @@ function rankEvictionCandidates(db, opts) {
     return left.memory.priority - right.memory.priority;
   });
 }
+function parseEnvInt(envKey) {
+  const raw = process.env[envKey];
+  if (raw === void 0 || raw === "") return null;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function getTieredCapacity(opts) {
+  const envMax = parseEnvInt("AGENT_MEMORY_MAX_MEMORIES");
+  return {
+    identity: parseEnvInt("AGENT_MEMORY_MAX_IDENTITY"),
+    // default: null (unlimited)
+    emotion: parseEnvInt("AGENT_MEMORY_MAX_EMOTION") ?? 50,
+    knowledge: parseEnvInt("AGENT_MEMORY_MAX_KNOWLEDGE") ?? 250,
+    event: parseEnvInt("AGENT_MEMORY_MAX_EVENT") ?? 50,
+    total: opts?.maxMemories ?? (envMax ?? 350)
+  };
+}
 function runGovern(db, opts) {
   const agentId = opts?.agent_id;
-  const envMax = Number.parseInt(process.env.AGENT_MEMORY_MAX_MEMORIES ?? "", 10);
-  const maxMemories = opts?.maxMemories ?? (Number.isFinite(envMax) && envMax > 0 ? envMax : 200);
+  const capacity = getTieredCapacity(opts);
   let orphanPaths = 0;
   let emptyMemories = 0;
   let evicted = 0;
+  let archived = 0;
+  const evictedByType = {};
   const transaction = db.transaction(() => {
     const pathResult = agentId ? db.prepare(
       `DELETE FROM paths
@@ -2791,17 +3001,48 @@ function runGovern(db, opts) {
     orphanPaths = pathResult.changes;
     const emptyResult = agentId ? db.prepare("DELETE FROM memories WHERE agent_id = ? AND TRIM(content) = ''").run(agentId) : db.prepare("DELETE FROM memories WHERE TRIM(content) = ''").run();
     emptyMemories = emptyResult.changes;
+    const typeLimits = [
+      { type: "identity", limit: capacity.identity },
+      { type: "emotion", limit: capacity.emotion },
+      { type: "knowledge", limit: capacity.knowledge },
+      { type: "event", limit: capacity.event }
+    ];
+    const allCandidates = rankEvictionCandidates(db, { agent_id: agentId });
+    const evictedIds = /* @__PURE__ */ new Set();
+    for (const { type, limit } of typeLimits) {
+      if (limit === null) continue;
+      const typeCount = db.prepare(
+        agentId ? "SELECT COUNT(*) as c FROM memories WHERE agent_id = ? AND type = ?" : "SELECT COUNT(*) as c FROM memories WHERE type = ?"
+      ).get(...agentId ? [agentId, type] : [type]).c;
+      const excess = Math.max(0, typeCount - limit);
+      if (excess <= 0) continue;
+      const typeCandidates = allCandidates.filter((c) => c.memory.type === type && !evictedIds.has(c.memory.id));
+      const toEvict = typeCandidates.slice(0, excess);
+      for (const candidate of toEvict) {
+        const result = archiveMemory(db, candidate.memory.id, "eviction");
+        evictedIds.add(candidate.memory.id);
+        evicted += 1;
+        if (result === "archived") archived += 1;
+        evictedByType[type] = (evictedByType[type] ?? 0) + 1;
+      }
+    }
     const total = db.prepare(agentId ? "SELECT COUNT(*) as c FROM memories WHERE agent_id = ?" : "SELECT COUNT(*) as c FROM memories").get(...agentId ? [agentId] : []).c;
-    const excess = Math.max(0, total - maxMemories);
-    if (excess <= 0) return;
-    const candidates = rankEvictionCandidates(db, { agent_id: agentId }).slice(0, excess);
-    for (const candidate of candidates) {
-      deleteMemory(db, candidate.memory.id);
-      evicted += 1;
+    const globalExcess = Math.max(0, total - capacity.total);
+    if (globalExcess > 0) {
+      const globalCandidates = allCandidates.filter((c) => !evictedIds.has(c.memory.id));
+      const toEvict = globalCandidates.slice(0, globalExcess);
+      for (const candidate of toEvict) {
+        const result = archiveMemory(db, candidate.memory.id, "eviction");
+        evictedIds.add(candidate.memory.id);
+        evicted += 1;
+        if (result === "archived") archived += 1;
+        const t = candidate.memory.type;
+        evictedByType[t] = (evictedByType[t] ?? 0) + 1;
+      }
     }
   });
   transaction();
-  return { orphanPaths, emptyMemories, evicted };
+  return { orphanPaths, emptyMemories, evicted, archived, evictedByType };
 }
 
 // src/sleep/jobs.ts
@@ -3042,12 +3283,21 @@ function getMemoryStatus(db, input) {
   const feedbackEvents = db.prepare(
     "SELECT COUNT(*) as c FROM feedback_events WHERE agent_id = ?"
   ).get(agentId);
+  const tiered = getTieredCapacity();
+  const capacity = {
+    identity: { count: stats.by_type.identity ?? 0, limit: tiered.identity },
+    emotion: { count: stats.by_type.emotion ?? 0, limit: tiered.emotion },
+    knowledge: { count: stats.by_type.knowledge ?? 0, limit: tiered.knowledge },
+    event: { count: stats.by_type.event ?? 0, limit: tiered.event },
+    total: { count: stats.total, limit: tiered.total }
+  };
   return {
     ...stats,
     paths: totalPaths.c,
     low_vitality: lowVitality.c,
     feedback_events: feedbackEvents.c,
-    agent_id: agentId
+    agent_id: agentId,
+    capacity
   };
 }
 
@@ -4001,6 +4251,7 @@ function boot(db, opts) {
   return result;
 }
 export {
+  archiveMemory,
   boot,
   buildFtsQuery,
   buildMergePlan,
@@ -4048,11 +4299,13 @@ export {
   getPathsByDomain,
   getPathsByMemory,
   getPathsByPrefix,
+  getTieredCapacity,
   guard,
   healthcheckEmbeddingProvider,
   ingestText,
   isCountRow,
   isStaleContent,
+  listArchivedMemories,
   listMemories,
   listPendingEmbeddings,
   loadWarmBootLayers,
@@ -4062,6 +4315,7 @@ export {
   openDatabase,
   parseUri,
   priorityPrior,
+  purgeArchive,
   rankEvictionCandidates,
   rebuildBm25Index,
   recallMemories,
@@ -4074,6 +4328,7 @@ export {
   reindexMemories,
   reindexMemorySearch,
   rememberMemory,
+  restoreMemory,
   runAutoIngestWatcher,
   runDecay,
   runGovern,