@agenr/openclaw-plugin 0.12.1 → 0.12.3

package/dist/index.js

@@ -107,7 +107,7 @@ var init_logger = __esm({
 });
 
 // src/db/schema/definitions.ts
-var CREATE_IDX_ENTRIES_EMBEDDING_SQL, CREATE_ENTRIES_FTS_TABLE_SQL, CREATE_ENTRIES_FTS_TRIGGER_AI_SQL, CREATE_ENTRIES_FTS_TRIGGER_AD_SQL, CREATE_ENTRIES_FTS_TRIGGER_AU_SQL, CREATE_TABLE_AND_TRIGGER_STATEMENTS, COLUMN_MIGRATIONS, CREATE_INDEX_STATEMENTS;
+var CREATE_IDX_ENTRIES_EMBEDDING_SQL, CREATE_ENTRIES_FTS_TABLE_SQL, CREATE_ENTRIES_FTS_TRIGGER_AI_SQL, CREATE_ENTRIES_FTS_TRIGGER_AD_SQL, CREATE_ENTRIES_FTS_TRIGGER_AU_SQL, CREATE_SEEN_SESSIONS_TABLE_SQL, CREATE_SEEN_SESSIONS_SEEN_AT_INDEX_SQL, CREATE_SESSION_PROJECTS_TABLE_SQL, CREATE_SESSION_IDENTITY_BREADCRUMBS_TABLE_SQL, CREATE_SESSION_IDENTITY_BREADCRUMBS_UPDATED_AT_INDEX_SQL, ADD_SESSION_PROJECT_STATE_COLUMN_SQL, OPENCLAW_PLUGIN_SCHEMA_STATEMENTS, OPENCLAW_PLUGIN_COLUMN_MIGRATIONS, CREATE_TABLE_AND_TRIGGER_STATEMENTS, COLUMN_MIGRATIONS, CREATE_INDEX_STATEMENTS;
 var init_definitions = __esm({
   "src/db/schema/definitions.ts"() {
     "use strict";
@@ -146,6 +146,60 @@ var init_definitions = __esm({
     WHERE new.retired = 0 AND new.superseded_by IS NULL;
   END
 `;
+    CREATE_SEEN_SESSIONS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS seen_sessions (
+    dedupe_key TEXT PRIMARY KEY,
+    seen_at INTEGER NOT NULL
+  )
+`;
+    CREATE_SEEN_SESSIONS_SEEN_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_seen_sessions_seen_at
+  ON seen_sessions(seen_at)
+`;
+    CREATE_SESSION_PROJECTS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS session_projects (
+    session_key TEXT PRIMARY KEY,
+    project TEXT NOT NULL,
+    state TEXT NOT NULL DEFAULT 'set',
+    updated_at TEXT NOT NULL
+  )
+`;
+    CREATE_SESSION_IDENTITY_BREADCRUMBS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS session_identity_breadcrumbs (
+    session_id TEXT PRIMARY KEY,
+    session_key TEXT,
+    family TEXT NOT NULL,
+    lane_id TEXT,
+    origin_surface TEXT,
+    delivery_channel TEXT,
+    family_source TEXT,
+    lane_source TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+`;
+    CREATE_SESSION_IDENTITY_BREADCRUMBS_UPDATED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_session_identity_breadcrumbs_updated_at
+  ON session_identity_breadcrumbs(updated_at)
+`;
+    ADD_SESSION_PROJECT_STATE_COLUMN_SQL = `
+  ALTER TABLE session_projects
+  ADD COLUMN state TEXT NOT NULL DEFAULT 'set'
+`;
+    OPENCLAW_PLUGIN_SCHEMA_STATEMENTS = [
+      CREATE_SEEN_SESSIONS_TABLE_SQL,
+      CREATE_SEEN_SESSIONS_SEEN_AT_INDEX_SQL,
+      CREATE_SESSION_PROJECTS_TABLE_SQL,
+      CREATE_SESSION_IDENTITY_BREADCRUMBS_TABLE_SQL,
+      CREATE_SESSION_IDENTITY_BREADCRUMBS_UPDATED_AT_INDEX_SQL
+    ];
+    OPENCLAW_PLUGIN_COLUMN_MIGRATIONS = [
+      {
+        table: "session_projects",
+        column: "state",
+        sql: ADD_SESSION_PROJECT_STATE_COLUMN_SQL
+      }
+    ];
     CREATE_TABLE_AND_TRIGGER_STATEMENTS = [
       `
   CREATE TABLE IF NOT EXISTS _meta (
@@ -419,9 +473,11 @@ var init_definitions = __esm({
       CREATE_ENTRIES_FTS_TABLE_SQL,
       CREATE_ENTRIES_FTS_TRIGGER_AI_SQL,
       CREATE_ENTRIES_FTS_TRIGGER_AD_SQL,
-      CREATE_ENTRIES_FTS_TRIGGER_AU_SQL
+      CREATE_ENTRIES_FTS_TRIGGER_AU_SQL,
+      ...OPENCLAW_PLUGIN_SCHEMA_STATEMENTS
     ];
     COLUMN_MIGRATIONS = [
+      ...OPENCLAW_PLUGIN_COLUMN_MIGRATIONS,
       {
         table: "co_recall_edges",
         column: "edge_type",
@@ -693,6 +749,202 @@ var init_definitions = __esm({
   }
 });
 
+// src/db/vector-index.ts
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return Number(value);
+  }
+  return Number.NaN;
+}
+function toFiniteCount(value) {
+  const numeric = toNumber(value);
+  if (!Number.isFinite(numeric)) {
+    return 0;
+  }
+  return Math.max(0, Math.trunc(numeric));
+}
+function normalizeRowid(value) {
+  const numeric = toNumber(value);
+  if (!Number.isFinite(numeric)) {
+    return null;
+  }
+  const rowid = Math.trunc(numeric);
+  return rowid > 0 ? rowid : null;
+}
+function formatShadowMismatch(stats) {
+  const details = [`active=${stats.embeddingCount}`, `shadow=${stats.shadowCount}`];
+  if (stats.missingRowids.length > 0) {
+    details.push(`missing=${stats.missingRowids.length}`);
+  }
+  return details.join(", ");
+}
+async function rollbackQuietly(db) {
+  try {
+    await db.execute("ROLLBACK");
+  } catch {
+  }
+}
+async function dropRepairTableQuietly(db) {
+  try {
+    await db.execute(`DROP TABLE IF EXISTS ${TEMP_REPAIR_TABLE}`);
+  } catch {
+  }
+}
+async function repairMissingRowids(db, missingRowids) {
+  if (missingRowids.length === 0) {
+    return;
+  }
+  await db.execute(`DROP TABLE IF EXISTS ${TEMP_REPAIR_TABLE}`);
+  await db.execute(`
+    CREATE TEMP TABLE ${TEMP_REPAIR_TABLE} (
+      rid INTEGER PRIMARY KEY,
+      emb BLOB NOT NULL
+    )
+  `);
+  try {
+    for (let index = 0; index < missingRowids.length; index += REPAIR_CHUNK_SIZE) {
+      const chunk = missingRowids.slice(index, index + REPAIR_CHUNK_SIZE);
+      if (chunk.length === 0) {
+        continue;
+      }
+      const placeholders = chunk.map(() => "?").join(", ");
+      await db.execute(`DELETE FROM ${TEMP_REPAIR_TABLE}`);
+      await db.execute({
+        sql: `
+          INSERT INTO ${TEMP_REPAIR_TABLE} (rid, emb)
+          SELECT rowid, embedding
+          FROM entries
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET embedding = NULL
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET embedding = (
+            SELECT emb
+            FROM ${TEMP_REPAIR_TABLE}
+            WHERE rid = entries.rowid
+          )
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+    }
+  } finally {
+    await dropRepairTableQuietly(db);
+  }
+}
+async function getVectorIndexShadowStats(db) {
+  const countsResult = await db.execute(`
+    SELECT
+      (SELECT COUNT(*) FROM entries WHERE ${ACTIVE_EMBEDDED_WHERE_SQL}) AS embedding_count,
+      (SELECT COUNT(*) FROM idx_entries_embedding_shadow) AS shadow_count
+  `);
+  const countsRow = countsResult.rows[0];
+  const embeddingCount = toFiniteCount(countsRow?.embedding_count);
+  const shadowCount = toFiniteCount(countsRow?.shadow_count);
+  const missingResult = await db.execute(`
+    SELECT e.rowid AS rowid
+    FROM entries AS e
+    LEFT JOIN idx_entries_embedding_shadow AS s
+      ON s.index_key = e.rowid
+    WHERE e.embedding IS NOT NULL
+      AND e.retired = 0
+      AND e.superseded_by IS NULL
+      AND s.index_key IS NULL
+    ORDER BY e.rowid ASC
+  `);
+  const missingRowids = missingResult.rows.map((row) => normalizeRowid(row.rowid)).filter((rowid) => rowid !== null);
+  return {
+    embeddingCount,
+    shadowCount,
+    missingRowids
+  };
+}
+async function rebuildVectorIndex(db, options) {
+  const start = Date.now();
+  const onLog = options?.onLog ?? (() => void 0);
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
+    await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
+    await db.execute(SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL);
+    const beforeRepair = await getVectorIndexShadowStats(db);
+    let repairedCount = 0;
+    if (beforeRepair.missingRowids.length > 0) {
+      repairedCount = beforeRepair.missingRowids.length;
+      onLog(`[vector-index] repairing ${repairedCount} entries missing from shadow table`);
+      await repairMissingRowids(db, beforeRepair.missingRowids);
+    }
+    const afterRepair = await getVectorIndexShadowStats(db);
+    if (afterRepair.missingRowids.length > 0 || afterRepair.shadowCount !== afterRepair.embeddingCount) {
+      throw new Error(`Vector index shadow table desynced after rebuild (${formatShadowMismatch(afterRepair)})`);
+    }
+    if (afterRepair.embeddingCount > 0) {
+      const verify = await db.execute(`
+        SELECT count(*) AS count
+        FROM vector_top_k(
+          'idx_entries_embedding',
+          (SELECT embedding FROM entries WHERE ${ACTIVE_EMBEDDED_WHERE_SQL} LIMIT 1),
+          1
+        )
+      `);
+      const verifyCount = toFiniteCount(verify.rows[0]?.count);
+      if (verifyCount !== 1) {
+        throw new Error(`Vector index rebuild verification failed (expected 1, got ${verifyCount})`);
+      }
+    }
+    await db.execute("COMMIT");
+    const durationMs = Date.now() - start;
+    onLog(
+      `[vector-index] rebuilt for ${afterRepair.embeddingCount} entries (${afterRepair.shadowCount} shadow rows, ${repairedCount} repaired, ${durationMs}ms)`
+    );
+    return {
+      embeddingCount: afterRepair.embeddingCount,
+      shadowCount: afterRepair.shadowCount,
+      repairedCount,
+      durationMs
+    };
+  } catch (error) {
+    await rollbackQuietly(db);
+    throw error;
+  }
+}
+var ACTIVE_EMBEDDED_WHERE_SQL, SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL, TEMP_REPAIR_TABLE, REPAIR_CHUNK_SIZE;
+var init_vector_index = __esm({
+  "src/db/vector-index.ts"() {
+    "use strict";
+    init_definitions();
+    ACTIVE_EMBEDDED_WHERE_SQL = `
+  embedding IS NOT NULL
+    AND retired = 0
+    AND superseded_by IS NULL
+`;
+    SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL = `
+  UPDATE entries
+  SET embedding = embedding
+  WHERE ${ACTIVE_EMBEDDED_WHERE_SQL}
+`;
+    TEMP_REPAIR_TABLE = "_vec_repair";
+    REPAIR_CHUNK_SIZE = 100;
+  }
+});
+
 // src/db/schema/fts.ts
 async function rebuildEntriesFts(db) {
   await db.execute("INSERT INTO entries_fts(entries_fts) VALUES('delete-all')");
@@ -727,31 +979,16 @@ async function rebuildFtsAndTriggers(db) {
     throw error;
   }
 }
-async function rebuildVectorIndex(db) {
+async function rebuildVectorIndex2(db) {
   try {
     await db.execute("REINDEX idx_entries_embedding");
-    return;
-  } catch {
-  }
-  await db.execute("BEGIN IMMEDIATE");
-  try {
-    await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
-    await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
-    await db.execute(`
-      UPDATE entries
-      SET embedding = embedding
-      WHERE embedding IS NOT NULL
-        AND retired = 0
-        AND superseded_by IS NULL
-    `);
-    await db.execute("COMMIT");
-  } catch (fallbackError) {
-    try {
-      await db.execute("ROLLBACK");
-    } catch {
+    const stats = await getVectorIndexShadowStats(db);
+    if (stats.shadowCount === stats.embeddingCount && stats.missingRowids.length === 0) {
+      return;
     }
-    throw fallbackError;
+  } catch {
   }
+  await rebuildVectorIndex(db);
 }
 async function clearBulkIngestMeta(db) {
   await db.execute({ sql: "DELETE FROM _meta WHERE key = ?", args: [BULK_INGEST_META_KEY] });
@@ -777,6 +1014,7 @@ var BULK_INGEST_META_KEY;
 var init_bulk_ingest = __esm({
   "src/db/schema/bulk-ingest.ts"() {
     "use strict";
+    init_vector_index();
     init_definitions();
     init_fts();
     BULK_INGEST_META_KEY = "bulk_ingest_state";
@@ -1358,15 +1596,10 @@ async function repairVectorIndexIfNeeded(client) {
     if (probeCount > 0) {
       return;
     }
-    await client.execute("DROP INDEX IF EXISTS idx_entries_embedding");
-    await client.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
-    await client.execute(`
-      UPDATE entries
-      SET embedding = embedding
-      WHERE embedding IS NOT NULL
-        AND retired = 0
-        AND superseded_by IS NULL
-    `);
+  } catch {
+  }
+  try {
+    await rebuildVectorIndex(client);
   } catch {
   }
 }
@@ -1395,6 +1628,7 @@ var init_init = __esm({
     init_version();
     init_reflection_importance_cap();
     init_reflection_removal();
+    init_vector_index();
     init_definitions();
     init_entry_provenance();
     init_fts();
@@ -1596,7 +1830,7 @@ async function checkAndRecoverBulkIngest(client) {
       }
     }
     if (indexCount < 1) {
-      await rebuildVectorIndex(client);
+      await rebuildVectorIndex2(client);
     }
     try {
       const integrityResult = await client.execute("PRAGMA integrity_check");
@@ -4428,7 +4662,7 @@ var init_source_classification = __esm({
 });
 
 // src/utils/entry-utils.ts
-function toNumber(value) {
+function toNumber2(value) {
   if (typeof value === "number") {
     return value;
   }
@@ -4537,10 +4771,10 @@ function mapRawStoredEntry(row, options) {
   const entryKind = toStringValue(row.entry_kind).trim();
   const temporalClass = toStringValue(row.temporal_class).trim();
   const scopeRaw = toStringValue(row.scope).trim();
-  const importanceRaw = toNumber(row.importance);
-  const confirmationsRaw = toNumber(row.confirmations);
-  const contradictionsRaw = toNumber(row.contradictions);
-  const qualityScoreRaw = toNumber(row.quality_score);
+  const importanceRaw = toNumber2(row.importance);
+  const confirmationsRaw = toNumber2(row.confirmations);
+  const contradictionsRaw = toNumber2(row.contradictions);
+  const qualityScoreRaw = toNumber2(row.quality_score);
   const subjectEntity = toStringValue(row.subject_entity).trim();
   const subjectAttribute = toStringValue(row.subject_attribute).trim();
   const subjectKey2 = toStringValue(row.subject_key).trim();
@@ -4548,8 +4782,8 @@ function mapRawStoredEntry(row, options) {
   const claimObject = toStringValue(row.claim_object).trim();
   const claimRole = toStringValue(row.claim_role).trim();
   const normalizedClaimRole = normalizeClaimRole2(claimRole);
-  const claimConfidenceRaw = toNumber(row.claim_confidence);
-  const retiredRaw = toNumber(row.retired);
+  const claimConfidenceRaw = toNumber2(row.claim_confidence);
+  const retiredRaw = toNumber2(row.retired);
   const clusterId = toStringValue(row.cluster_id).trim();
   const sourceClass = normalizeSourceClass(toStringValue(row.source_class));
   const suppressedContextsRaw = toStringValue(row.suppressed_contexts);
@@ -4752,14 +4986,14 @@ function normalizeEntryIds(entryIds) {
   );
 }
 function parseCount(value) {
-  const parsed = toNumber(value);
+  const parsed = toNumber2(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return 0;
   }
   return Math.floor(parsed);
 }
 function parseSignalTotal(value) {
-  const parsed = toNumber(value);
+  const parsed = toNumber2(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return 0;
   }
@@ -4773,7 +5007,7 @@ function parseIsoTimestamp(value) {
   return normalized.length > 0 ? normalized : null;
 }
 function parseGapDays(value) {
-  const parsed = toNumber(value);
+  const parsed = toNumber2(value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return 0;
   }
@@ -4979,7 +5213,7 @@ async function getStoredEntryById(db, id) {
 }
 async function getTotalEntries(db) {
   const result = await db.execute("SELECT COUNT(*) AS count FROM entries");
-  const count = toNumber(result.rows[0]?.count);
+  const count = toNumber2(result.rows[0]?.count);
   return Number.isFinite(count) ? count : 0;
 }
 async function hasContentHash(db, contentHash) {
@@ -5344,7 +5578,7 @@ async function findRecentEntriesBySubjectTypeAndSourceFile(db, requests) {
         normalizedSubject: toStringValue(row.lookup_normalized_subject),
         type: toStringValue(row.lookup_type),
         sourceFile: toStringValue(row.lookup_source_file),
-        withinHours: toNumber(row.lookup_within_hours),
+        withinHours: toNumber2(row.lookup_within_hours),
         entry: mapEntryRow(row, { tags: tagsById.get(entryId) ?? [], includeEmbedding: true })
       });
     }
@@ -5879,6 +6113,10 @@ var init_similarity = __esm({
 
 // src/utils/content-fingerprint.ts
 import { createHash as createHash3 } from "crypto";
+function computeNormContentHash(content) {
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim().replace(/[^\w\s]/g, "");
+  return createHash3("sha256").update(normalized).digest("hex");
+}
 var init_content_fingerprint = __esm({
   "src/utils/content-fingerprint.ts"() {
     "use strict";
@@ -6278,12 +6516,12 @@ async function getConflictShadowSummary(db) {
       continue;
     }
     const relationSummary = {
-      totalEvaluated: Number.isFinite(toNumber(record.total)) ? toNumber(record.total) : 0,
-      blockedAtCurrent: Number.isFinite(toNumber(record.blocked_current)) ? toNumber(record.blocked_current) : 0,
-      currentOnlyBand: Number.isFinite(toNumber(record.current_only)) ? toNumber(record.current_only) : 0,
-      wouldStillBlockAt090: Number.isFinite(toNumber(record.still_block_090)) ? toNumber(record.still_block_090) : 0,
-      wouldStillBlockAt095: Number.isFinite(toNumber(record.still_block_095)) ? toNumber(record.still_block_095) : 0,
-      silentCoexistBand: Number.isFinite(toNumber(record.silent_coexist)) ? toNumber(record.silent_coexist) : 0
+      totalEvaluated: Number.isFinite(toNumber2(record.total)) ? toNumber2(record.total) : 0,
+      blockedAtCurrent: Number.isFinite(toNumber2(record.blocked_current)) ? toNumber2(record.blocked_current) : 0,
+      currentOnlyBand: Number.isFinite(toNumber2(record.current_only)) ? toNumber2(record.current_only) : 0,
+      wouldStillBlockAt090: Number.isFinite(toNumber2(record.still_block_090)) ? toNumber2(record.still_block_090) : 0,
+      wouldStillBlockAt095: Number.isFinite(toNumber2(record.still_block_095)) ? toNumber2(record.still_block_095) : 0,
+      silentCoexistBand: Number.isFinite(toNumber2(record.silent_coexist)) ? toNumber2(record.silent_coexist) : 0
     };
     byRelation[relation] = relationSummary;
     totalEvaluated += relationSummary.totalEvaluated;
@@ -6732,7 +6970,7 @@ async function getCoRecallEdgeCounts(db) {
     if (!entryId) {
       continue;
     }
-    counts.set(entryId, Math.max(0, toNumber(row.edge_count)));
+    counts.set(entryId, Math.max(0, toNumber2(row.edge_count)));
   }
   return counts;
 }
@@ -7042,10 +7280,10 @@ async function evolveQualityScores(db, options = {}, config) {
     return {
       id,
       type: toStringValue(row.type),
-      importance: Math.max(0, toNumber(row.importance)),
+      importance: Math.max(0, toNumber2(row.importance)),
       recallCount: Math.max(0, metrics?.totalCount ?? 0),
-      confirmations: Math.max(0, toNumber(row.confirmations)),
-      qualityScore: toNumber(row.quality_score),
+      confirmations: Math.max(0, toNumber2(row.confirmations)),
+      qualityScore: toNumber2(row.quality_score),
       lastRecalledAt: metrics?.lastLiveRecalledAt ?? metrics?.lastAnyRecalledAt ?? "",
       createdAt: toStringValue(row.created_at)
     };
@@ -7402,8 +7640,8 @@ async function fetchRecalledEntryMetrics(db, entryIds) {
   });
   return result.rows.map((row) => ({
     id: toStringValue(row.id),
-    qualityScore: toNumber(row.quality_score),
-    recallEventsCount: toNumber(row.recall_events_count)
+    qualityScore: toNumber2(row.quality_score),
+    recallEventsCount: toNumber2(row.recall_events_count)
   }));
 }
 async function processBeforeResetRecallFeedback(request, deps) {
@@ -7481,66 +7719,6 @@ var init_watcher_demotion = __esm({
   }
 });
 
-// src/db/vector-index.ts
-function toNumber2(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return Number(value);
-  }
-  if (typeof value === "string" && value.trim()) {
-    return Number(value);
-  }
-  return Number.NaN;
-}
-async function rebuildVectorIndex2(db, options) {
-  const start = Date.now();
-  const onLog = options?.onLog ?? (() => void 0);
-  await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
-  await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
-  await db.execute(`
-    UPDATE entries
-    SET embedding = embedding
-    WHERE embedding IS NOT NULL
-      AND retired = 0
-      AND superseded_by IS NULL
-  `);
-  const result = await db.execute(`
-    SELECT COUNT(*) AS count
-    FROM entries
-    WHERE embedding IS NOT NULL
-      AND retired = 0
-      AND superseded_by IS NULL
-  `);
-  const embeddingCountRaw = result.rows[0]?.count;
-  const embeddingCount = Number.isFinite(toNumber2(embeddingCountRaw)) ? toNumber2(embeddingCountRaw) : 0;
-  if (embeddingCount > 0) {
-    const verify = await db.execute(`
-      SELECT count(*) AS count
-      FROM vector_top_k(
-        'idx_entries_embedding',
-        (SELECT embedding FROM entries WHERE embedding IS NOT NULL AND retired = 0 AND superseded_by IS NULL LIMIT 1),
-        1
-      )
-    `);
-    const verifyCountRaw = verify.rows[0]?.count;
-    const verifyCount = Number.isFinite(toNumber2(verifyCountRaw)) ? toNumber2(verifyCountRaw) : 0;
-    if (verifyCount !== 1) {
-      throw new Error(`Vector index rebuild verification failed (expected 1, got ${verifyCount})`);
-    }
-  }
-  const durationMs = Date.now() - start;
-  onLog(`[vector-index] rebuilt for ${embeddingCount} entries (${durationMs}ms)`);
-  return { embeddingCount, durationMs };
-}
-var init_vector_index = __esm({
-  "src/db/vector-index.ts"() {
-    "use strict";
-    init_schema();
-  }
-});
-
 // src/runtime/db-command-defaults.ts
 function resolveDbCommandDefaults() {
   const shared = resolveDefaultAppRuntimeDeps();
@@ -7553,7 +7731,7 @@ function resolveDbCommandDefaults() {
     getConflictShadowSummary,
     resetDb,
     walCheckpoint,
-    rebuildVectorIndex: rebuildVectorIndex2,
+    rebuildVectorIndex,
     evolveQualityScores
   };
 }
@@ -8430,6 +8608,7 @@ function formatMidSessionRecall(results, options = {}) {
 
 // src/runtime/openclaw-defaults.ts
 init_client();
+init_schema();
 
 // src/db/signals.ts
 async function fetchNewSignalEntries(db, sinceSeq, minImportance, limit, maxAgeSec = 0) {
@@ -8546,7 +8725,9 @@ function resolveOpenClawPluginDbDefaults() {
   return {
     getDb: shared.getDbFn,
     initDb: shared.initDbFn,
-    closeDb: shared.closeDbFn
+    closeDb: shared.closeDbFn,
+    pluginSchemaStatements: OPENCLAW_PLUGIN_SCHEMA_STATEMENTS,
+    pluginColumnMigrations: OPENCLAW_PLUGIN_COLUMN_MIGRATIONS
   };
 }
 function resolveOpenClawSignalDefaults() {
@@ -8566,46 +8747,6 @@ function resolveOpenClawHandoffDefaults() {
 }
 
 // src/openclaw-plugin/plugin-db.ts
-var CREATE_SEEN_SESSIONS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS seen_sessions (
-    dedupe_key TEXT PRIMARY KEY,
-    seen_at INTEGER NOT NULL
-  )
-`;
-var CREATE_SEEN_SESSIONS_SEEN_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_seen_sessions_seen_at
-  ON seen_sessions(seen_at)
-`;
-var CREATE_SESSION_PROJECTS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS session_projects (
-    session_key TEXT PRIMARY KEY,
-    project TEXT NOT NULL,
-    state TEXT NOT NULL DEFAULT 'set',
-    updated_at TEXT NOT NULL
-  )
-`;
-var CREATE_SESSION_IDENTITY_BREADCRUMBS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS session_identity_breadcrumbs (
-    session_id TEXT PRIMARY KEY,
-    session_key TEXT,
-    family TEXT NOT NULL,
-    lane_id TEXT,
-    origin_surface TEXT,
-    delivery_channel TEXT,
-    family_source TEXT,
-    lane_source TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )
-`;
-var CREATE_SESSION_IDENTITY_BREADCRUMBS_UPDATED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_session_identity_breadcrumbs_updated_at
-  ON session_identity_breadcrumbs(updated_at)
-`;
-var ADD_SESSION_PROJECT_STATE_COLUMN_SQL = `
-  ALTER TABLE session_projects
-  ADD COLUMN state TEXT NOT NULL DEFAULT 'set'
-`;
 var PLUGIN_DB_STATE_KEY = "__agenrOpenClawPluginDbState";
 function getPluginDbState() {
   const globalState = globalThis;
@@ -8625,18 +8766,19 @@ function closePluginDbState(state) {
   state.init = null;
 }
 async function ensurePluginDbTables(client) {
-  await resolveOpenClawPluginDbDefaults().initDb(client);
-  await client.execute(CREATE_SEEN_SESSIONS_TABLE_SQL);
-  await client.execute(CREATE_SEEN_SESSIONS_SEEN_AT_INDEX_SQL);
-  await client.execute(CREATE_SESSION_PROJECTS_TABLE_SQL);
-  await client.execute(CREATE_SESSION_IDENTITY_BREADCRUMBS_TABLE_SQL);
-  await client.execute(CREATE_SESSION_IDENTITY_BREADCRUMBS_UPDATED_AT_INDEX_SQL);
-  const sessionProjectsInfo = await client.execute("PRAGMA table_info(session_projects)");
-  const hasStateColumn = sessionProjectsInfo.rows.some(
-    (row) => String(row.name) === "state"
-  );
-  if (!hasStateColumn) {
-    await client.execute(ADD_SESSION_PROJECT_STATE_COLUMN_SQL);
+  const defaults = resolveOpenClawPluginDbDefaults();
+  await defaults.initDb(client);
+  for (const statement of defaults.pluginSchemaStatements) {
+    await client.execute(statement);
+  }
+  for (const migration of defaults.pluginColumnMigrations) {
+    const tableInfo = await client.execute(`PRAGMA table_info(${migration.table})`);
+    const hasColumn2 = tableInfo.rows.some(
+      (row) => String(row.name) === migration.column
+    );
+    if (!hasColumn2) {
+      await client.execute(migration.sql);
+    }
   }
 }
 function registerDbShutdown(state) {
@@ -8882,6 +9024,47 @@ async function finalizeRecallResults(params) {
   return results;
 }
 
+// src/domain/recall/browse-selection.ts
+var DEFAULT_BROWSE_DIVERSITY_TARGET = 4;
+function normalizeEntryType(result) {
+  const rawType = result.entry.type;
+  return typeof rawType === "string" ? rawType.trim().toLowerCase() : "";
+}
+function diversifyBrowseResults(results, limit, diversityTarget = DEFAULT_BROWSE_DIVERSITY_TARGET) {
+  const normalizedLimit = Math.max(0, Math.floor(limit));
+  if (normalizedLimit === 0 || results.length === 0) {
+    return [];
+  }
+  const normalizedDiversityTarget = Math.max(0, Math.floor(diversityTarget));
+  const seedTarget = Math.min(normalizedLimit, normalizedDiversityTarget);
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const admittedTypes = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (selected.length >= seedTarget) {
+      break;
+    }
+    const normalizedType = normalizeEntryType(result);
+    if (!normalizedType || admittedTypes.has(normalizedType)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+    admittedTypes.add(normalizedType);
+  }
+  for (const result of results) {
+    if (selected.length >= normalizedLimit) {
+      break;
+    }
+    if (selectedIds.has(result.entry.id)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+  }
+  return selected;
+}
+
 // src/db/recall/pipeline/retrieval.ts
 init_client2();
 
@@ -9045,6 +9228,8 @@ var DEFAULT_RECALL_SATURATION = 10;
 var DEFAULT_WARM_START_THRESHOLD = 3;
 var DEFAULT_SYNTHETIC_FLOOR = 0.1;
 var DEFAULT_AGENT_SOURCE_BONUS = 0.05;
+var BROWSE_RECENCY_WEIGHT = 0.8;
+var BROWSE_IMPORTANCE_WEIGHT = 0.2;
 var MISSING_RECALL_DAYS = 99999;
 var EMPTY_RECALL_METRICS = {
   totalCount: 0,
@@ -9166,7 +9351,9 @@ function browseRecencyFactor(entry, now, aroundDate, aroundRadius = DEFAULT_AROU
   return resolveRecallRecency(entry, now, aroundDate, aroundRadius);
 }
 function scoreBrowseEntry(entry, now, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS) {
-  return clamp01((browseRecencyFactor(entry, now, aroundDate, aroundRadius) + importanceScore(entry.importance)) / 2);
+  const recency2 = browseRecencyFactor(entry, now, aroundDate, aroundRadius);
+  const importance = importanceScore(entry.importance);
+  return clamp01(recency2 * BROWSE_RECENCY_WEIGHT + importance * BROWSE_IMPORTANCE_WEIGHT);
 }
 function scoreSessionEntry(entry, effectiveNow, freshnessNow, metricsMap, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS, config) {
   return scoreEntryWithBreakdown(
@@ -9702,8 +9889,21 @@ async function fetchBrowseCandidates(params) {
     whereClauses.push("platform = ?");
     args.push(params.query.platform);
   }
-  args.push(params.limit);
   const whereClause = whereClauses.length > 0 ? "WHERE " + whereClauses.join(" AND ") : "";
+  const orderBy = params.aroundDate ? `
+      ORDER BY
+        ABS(julianday(created_at) - julianday(?)) ASC,
+        importance DESC,
+        created_at DESC
+    ` : `
+      ORDER BY
+        created_at DESC,
+        importance DESC
+    `;
+  if (params.aroundDate) {
+    args.push(params.aroundDate.toISOString());
+  }
+  args.push(params.limit);
   const result = await params.db.execute({
     sql: `
       SELECT
@@ -9711,10 +9911,10 @@ async function fetchBrowseCandidates(params) {
       FROM entries
       ${whereClause}
       -- SQL pre-sort is a best-effort approximation only.
-      -- Final order is determined by scoreBrowseEntry() (importance * recency decay)
-      -- which re-sorts post-fetch. The over-fetch buffer (limit*3, min 50)
+      -- Final order is determined by recency-first browse scoring and a post-score
+      -- diversity pass. The over-fetch buffer (limit*3, min 50)
       -- ensures the final top-N are present in the candidate pool.
-      ORDER BY importance DESC, created_at DESC
+      ${orderBy}
       LIMIT ?
     `,
     args
@@ -9947,6 +10147,7 @@ async function recallBrowseMode(params) {
     query: browseQuery,
     limit: browseLimit,
     now: params.now,
+    aroundDate: params.prepared.temporal.aroundDate,
     projectFilter: params.prepared.scope.resolution.primaryFilter
   });
   const filtered = browseCandidates.filter(
@@ -9967,7 +10168,11 @@ async function recallBrowseMode(params) {
     aroundRadiusDays: params.prepared.temporal.aroundRadiusDays
   });
   scored.sort((left, right) => right.score - left.score);
-  return scored.slice(0, requestedLimit);
+  const results = diversifyBrowseResults(scored, requestedLimit, DEFAULT_BROWSE_DIVERSITY_TARGET);
+  if (params.trace) {
+    params.trace.finalResultIds = results.map((result) => result.entry.subject ?? result.entry.id);
+  }
+  return results;
 }
 async function retrieveCandidates(params) {
   if (!params.prepared.retrievalSearchText) {
@@ -10377,11 +10582,12 @@ function resolvePreparedRecallScope(query, normalizedQuery) {
   const explicitWildcardProject = hasWildcardProjectOverride(query.project);
   const explicitProjects = explicitWildcardProject ? [] : parseProjectList(query.project);
   const explicitExcludedProjects = parseProjectList(query.excludeProject);
-  const inferredProjectHints = deriveRecallProjectScopeHints({
+  const inferredProjectHints = explicitWildcardProject ? [] : deriveRecallProjectScopeHints({
     queryText: normalizedQuery?.searchText ?? query.text ?? "",
     explicitProjects
   });
-  const projectHints = explicitProjects.length > 0 ? explicitProjects : inferredProjectHints;
+  const callerProjectHints = explicitProjects.length > 0 || explicitWildcardProject ? [] : parseProjectList(query.projectHints).filter((projectHint) => projectHint !== "*");
+  const projectHints = explicitProjects.length > 0 ? explicitProjects : Array.from(/* @__PURE__ */ new Set([...inferredProjectHints, ...callerProjectHints]));
   const intent = projectHints.length > 0 ? "project" : normalizedQuery?.scopeIntent ?? "ambiguous";
   if (query.universalOnly === true) {
     return {
@@ -12126,6 +12332,7 @@ function buildRecallQuery(request, options) {
     scope: request.scope ?? "private",
     platform: request.platform,
     project: request.project,
+    projectHints: request.projectHints,
     excludeProject: request.excludeProject,
     projectStrict: request.projectStrict,
     universalOnly: request.universalOnly,
@@ -12454,6 +12661,9 @@ async function sessionStartRecall2(request, deps) {
   });
 }
 
+// src/openclaw-plugin/recall.ts
+init_project();
+
 // src/openclaw-plugin/memory-index.ts
 init_errors();
 var MEMORY_INDEX_TIMEOUT_MS = 1e4;
@@ -12587,18 +12797,23 @@ function buildRecallRequest(budget, project, query, options) {
   const queryText = trimmedQuery.length > RECALL_QUERY_MAX_CHARS ? trimmedQuery.slice(0, RECALL_QUERY_MAX_CHARS) : trimmedQuery;
   const inferredSessionStart = isSessionStart || queryText.length === 0;
   const universalOnly = options?.nullProjectOnly === true || options?.universalOnly === true;
-  const explicitProjectsProvided = options?.project !== void 0;
+  const explicitWildcardProject = (options?.project ?? []).some(
+    (candidate) => candidate.split(",").some((part) => part.trim() === "*")
+  );
   const normalizedProjects = Array.from(new Set(
     (options?.project ?? []).map((candidate) => candidate.trim()).filter((candidate) => candidate.length > 0)
   ));
-  const resolvedProject = universalOnly ? void 0 : explicitProjectsProvided ? normalizedProjects.length > 0 ? normalizedProjects : void 0 : !project ? void 0 : [project];
-  const resolvedProjectStrict = universalOnly ? void 0 : explicitProjectsProvided ? options?.projectStrict ? true : void 0 : project && !universalOnly ? true : void 0;
+  const explicitProjectSelection = explicitWildcardProject || normalizedProjects.length > 0;
+  const normalizedProjectHints = parseProjectList(options?.projectHints).filter((projectHint) => projectHint !== "*");
+  const resolvedProject = universalOnly ? void 0 : explicitProjectSelection ? normalizedProjects.length > 0 ? normalizedProjects : void 0 : !project ? void 0 : [project];
+  const resolvedProjectStrict = universalOnly ? void 0 : explicitProjectSelection ? options?.projectStrict ? true : void 0 : project && !universalOnly ? true : void 0;
+  const resolvedProjectHints = universalOnly || explicitProjectSelection || explicitWildcardProject ? void 0 : normalizedProjectHints.length > 0 ? normalizedProjectHints : void 0;
   return {
     isBrowse,
     isSessionStart: !isBrowse && inferredSessionStart,
     limit: options?.limit ?? DEFAULT_LIMIT2,
     queryText,
-    since: isBrowse ? options?.since ?? "1d" : options?.since,
+    since: options?.since,
     types: options?.types,
     until: options?.until,
     around: options?.around,
@@ -12609,6 +12824,7 @@ function buildRecallRequest(budget, project, query, options) {
     universalOnly,
     project: resolvedProject,
     projectStrict: resolvedProjectStrict,
+    projectHints: resolvedProjectHints,
     budget: isBrowse ? void 0 : options?.budget === null ? void 0 : options?.budget ?? budget
   };
 }
@@ -12658,6 +12874,7 @@ async function executeRecallRequest(budget, project, query, options, dbPath, exe
       expiry: request.expiry,
       project: request.project,
       projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
       universalOnly: request.universalOnly,
       includeRecallCounts: false
     },
@@ -12678,6 +12895,7 @@ async function executeRecallRequest(budget, project, query, options, dbPath, exe
       expiry: request.expiry,
       project: request.project,
       projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
       universalOnly: request.universalOnly,
       updateMetadata,
       includeRecallCounts: false
@@ -12701,6 +12919,7 @@ async function executeRecallRequest(budget, project, query, options, dbPath, exe
       expiry: request.expiry,
       project: request.project,
       projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
       universalOnly: request.universalOnly,
       updateMetadata,
       includeRecallCounts: false
@@ -14923,6 +15142,31 @@ var genericJsonlAdapter = {
 
 // src/adapters/openclaw.ts
 import fs13 from "fs/promises";
+init_content_fingerprint();
+
+// src/utils/expiry.ts
+init_types();
+var EXPIRY_SET = new Set(EXPIRY_LEVELS);
+var EXPIRY_PRIORITY = {
+  temporary: 0,
+  permanent: 1,
+  core: 2
+};
+function normalizeExpiry(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  return EXPIRY_SET.has(normalized) ? normalized : void 0;
+}
+function resolveHigherExpiry(a, b) {
+  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
+}
+
+// src/adapters/openclaw.ts
 init_string();
 function normalizeOpenClawRole(value) {
   if (typeof value !== "string") {
@@ -14968,10 +15212,120 @@ function getStringArray(value) {
   const values = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
   return values.length > 0 ? values : void 0;
 }
+function parseJsonRecord(value) {
+  try {
+    return asRecord4(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+function normalizeProjectValue(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.toLowerCase() : void 0;
+}
 function normalizeSessionLabel(value) {
   const normalized = normalizeLabel(value);
   return normalized.length > 0 ? normalized : void 0;
 }
+function normalizeHintSubject(subject) {
+  const trimmed = subject?.trim().toLowerCase();
+  return trimmed ? trimmed : void 0;
+}
+function extractRecallResultsPayload(message, toolText) {
+  const details = asRecord4(message.details);
+  if (Array.isArray(details?.results)) {
+    return details.results;
+  }
+  const parsedPayload = parseJsonRecord(toolText);
+  if (Array.isArray(parsedPayload?.results)) {
+    return parsedPayload.results;
+  }
+  return [];
+}
+function extractRecallTargetHints(message, toolText) {
+  const hints = [];
+  for (const result of extractRecallResultsPayload(message, toolText)) {
+    const resultRecord = asRecord4(result);
+    const entryRecord = asRecord4(resultRecord?.entry);
+    const recalledEntryId = getString4(entryRecord?.id);
+    const type = getString4(entryRecord?.type);
+    const subject = getString4(entryRecord?.subject);
+    const content = getString4(entryRecord?.content);
+    if (!recalledEntryId || !type || !subject || !content) {
+      continue;
+    }
+    const source = asRecord4(entryRecord?.source);
+    hints.push({
+      recalledEntryId,
+      type,
+      subject,
+      normContentHash: computeNormContentHash(content),
+      project: normalizeProjectValue(getString4(entryRecord?.project)),
+      sourceFile: getString4(source?.file),
+      sourceContext: getString4(source?.context)
+    });
+  }
+  return hints;
+}
+function isRetireSuccessText(toolText) {
+  const entryLabelPattern = '\\S+(?:\\s+\\("(?:\\\\.|[^"])*"\\))?';
+  return new RegExp(`^Retired entry\\s+${entryLabelPattern}\\.\\s*$`, "i").test(toolText.trim());
+}
+function isUpdateSuccessText(toolText) {
+  const trimmed = toolText.trim();
+  const entryLabelPattern = '\\S+(?:\\s+\\("(?:\\\\.|[^"])*"\\))?';
+  const updatePart = "(?:importance\\s+\\d+\\s+(?:->|\u2192)\\s+\\d+|expiry\\s+(?:core|permanent|temporary)\\s+(?:->|\u2192)\\s+(?:core|permanent|temporary))";
+  return new RegExp(`^Updated entry\\s+${entryLabelPattern}\\s+importance:\\s+\\d+\\s+->\\s+\\d+\\.\\s*$`, "i").test(trimmed) || new RegExp(`^Entry\\s+${entryLabelPattern}\\s+already has importance\\s+\\d+\\.\\s*$`, "i").test(trimmed) || new RegExp(`^Updated entry\\s+${entryLabelPattern}:\\s+importance\\s+\u2192\\s+\\d+\\.\\s*$`, "i").test(trimmed) || new RegExp(`^Updated entry\\s+${entryLabelPattern}:\\s+${updatePart}(?:,\\s+${updatePart})*\\.\\s*$`, "i").test(trimmed) || new RegExp(`^Entry\\s+${entryLabelPattern}\\s+already has expiry\\s+(?:core|permanent|temporary)\\.\\s*$`, "i").test(trimmed) || new RegExp(`^Entry\\s+${entryLabelPattern}\\s+already has importance\\s+\\d+\\s+and\\s+expiry\\s+(?:core|permanent|temporary)\\.\\s*$`, "i").test(trimmed);
+}
+function isInactiveUpdateText(toolText) {
+  const entryLabelPattern = '\\S+(?:\\s+\\("(?:\\\\.|[^"])*"\\))?';
+  return new RegExp(
+    `^Entry\\s+${entryLabelPattern}\\s+was not updated because it is no longer active\\.\\s*$`,
+    "i"
+  ).test(toolText.trim());
+}
+function parseQuotedSubject(subjectToken) {
+  if (!subjectToken) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(subjectToken);
+    return typeof parsed === "string" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseRetireSuccessReceipt(toolText) {
+  const match = toolText.trim().match(
+    /^Retired entry\s+(\S+)(?:\s+\(("(?:(?:\\.)|[^"])*")\))?\.\s*$/i
+  );
+  if (!match) {
+    return null;
+  }
+  return {
+    entryId: match[1],
+    subject: parseQuotedSubject(match[2])
+  };
+}
+function parseUpdateReceiptEntry(toolText) {
+  const matchers = [
+    /^Updated entry\s+(\S+)(?:\s+\(("(?:(?:\\.)|[^"])*")\))?\s+importance:/i,
+    /^Updated entry\s+(\S+)(?:\s+\(("(?:(?:\\.)|[^"])*")\))?:/i,
+    /^Entry\s+(\S+)(?:\s+\(("(?:(?:\\.)|[^"])*")\))?\s+already has/i,
+    /^Entry\s+(\S+)(?:\s+\(("(?:(?:\\.)|[^"])*")\))?\s+was not updated because/i
+  ];
+  for (const matcher of matchers) {
+    const match = toolText.trim().match(matcher);
+    if (!match) {
+      continue;
+    }
+    return {
+      entryId: match[1],
+      subject: parseQuotedSubject(match[2])
+    };
+  }
+  return null;
+}
 function parsePendingAgentStoreEntry(value, defaultProject) {
   const record = asRecord4(value);
   if (!record) {
@@ -15125,11 +15479,43 @@ var openClawAdapter = {
     const modelsUsed = [];
     const modelsUsedSet = /* @__PURE__ */ new Set();
     const successfulAgentStoredEntries = [];
+    const successfulAgentRetires = [];
+    const successfulAgentUpdates = [];
     const agentStoreProjects = /* @__PURE__ */ new Set();
+    const recalledEntryHintsById = /* @__PURE__ */ new Map();
+    const recalledEntryHintsBySubject = /* @__PURE__ */ new Map();
     const pendingToolCalls = [];
     const pendingToolCallsById = /* @__PURE__ */ new Map();
     const pendingAgentStores = /* @__PURE__ */ new Map();
     const pendingAgentStoreQueue = [];
+    const pendingAgentRetires = /* @__PURE__ */ new Map();
+    const pendingAgentRetireQueue = [];
+    const pendingAgentUpdates = /* @__PURE__ */ new Map();
+    const pendingAgentUpdateQueue = [];
+    const appendRecalledEntryHint = (hint) => {
+      recalledEntryHintsById.set(hint.recalledEntryId, hint);
+      const subjectKey2 = normalizeHintSubject(hint.subject);
+      if (!subjectKey2) {
+        return;
+      }
+      const existing = recalledEntryHintsBySubject.get(subjectKey2) ?? [];
+      existing.push(hint);
+      recalledEntryHintsBySubject.set(subjectKey2, existing);
+    };
+    const resolveRecalledEntryHint = (entryId, subject) => {
+      if (entryId) {
+        const byId = recalledEntryHintsById.get(entryId);
+        if (byId) {
+          return byId;
+        }
+      }
+      const subjectKey2 = normalizeHintSubject(subject);
+      if (!subjectKey2) {
+        return void 0;
+      }
+      const bySubject = recalledEntryHintsBySubject.get(subjectKey2) ?? [];
+      return bySubject.length === 1 ? bySubject[0] : void 0;
+    };
     const addModelUsed = (value) => {
       const modelId = typeof value === "string" ? value.trim() : "";
       if (!modelId || modelsUsedSet.has(modelId)) {
@@ -15167,7 +15553,7 @@ var openClawAdapter = {
       }
       return pendingToolCalls.shift() ?? null;
     };
-    const resolvePendingAgentStore = (message, toolCallIdHint) => {
+    const resolvePendingAction = (message, byId, queue, toolCallIdHint) => {
       const candidateIds = [
         toolCallIdHint,
         getString4(message.toolCallId),
@@ -15176,14 +15562,23 @@ var openClawAdapter = {
         getString4(message.id)
       ].filter((value, index, all) => Boolean(value) && all.indexOf(value) === index);
       for (const id of candidateIds) {
-        const pending = pendingAgentStores.get(id);
+        const pending = byId.get(id);
         if (!pending) {
           continue;
         }
-        pendingAgentStores.delete(id);
+        byId.delete(id);
         return pending;
       }
-      return pendingAgentStoreQueue.shift() ?? null;
+      return queue.shift() ?? null;
+    };
+    const resolvePendingAgentStore = (message, toolCallIdHint) => {
+      return resolvePendingAction(message, pendingAgentStores, pendingAgentStoreQueue, toolCallIdHint);
+    };
+    const resolvePendingAgentRetire = (message, toolCallIdHint) => {
+      return resolvePendingAction(message, pendingAgentRetires, pendingAgentRetireQueue, toolCallIdHint);
+    };
+    const resolvePendingAgentUpdate = (message, toolCallIdHint) => {
+      return resolvePendingAction(message, pendingAgentUpdates, pendingAgentUpdateQueue, toolCallIdHint);
     };
     parseJsonlLines(raw, warnings, (record) => {
       if (record.type === "session") {
@@ -15249,28 +15644,75 @@ var openClawAdapter = {
         const toolCalls = extractToolCallBlocks(content);
         const assistantMessageIndex = messages.length;
         for (const call of toolCalls) {
+          const normalizedToolName = call.name.trim().toLowerCase();
           pendingToolCalls.push(call);
           if (call.id) {
             pendingToolCallsById.set(call.id, call);
           }
-          if (call.name.trim().toLowerCase() !== "agenr_store" || !Array.isArray(call.args.entries)) {
+          if (normalizedToolName === "agenr_store" && Array.isArray(call.args.entries)) {
+            const defaultProject = getString4(call.args.project);
+            const entries = call.args.entries.map((entry) => parsePendingAgentStoreEntry(entry, defaultProject)).filter((entry) => entry !== null);
+            if (entries.length === 0) {
+              continue;
+            }
+            const pending = {
+              entries,
+              toolCallId: call.id,
+              assistantMessageIndex,
+              timestamp: timestamp2
+            };
+            if (call.id) {
+              pendingAgentStores.set(call.id, pending);
+            } else {
+              pendingAgentStoreQueue.push(pending);
+            }
             continue;
           }
-          const defaultProject = getString4(call.args.project);
-          const entries = call.args.entries.map((entry) => parsePendingAgentStoreEntry(entry, defaultProject)).filter((entry) => entry !== null);
-          if (entries.length === 0) {
+          if (normalizedToolName === "agenr_retire") {
+            const entryId = getString4(call.args.entry_id);
+            const subject = getString4(call.args.subject);
+            if (!entryId && !subject || entryId && subject) {
+              continue;
+            }
+            const pending = {
+              ...entryId ? { entryId } : {},
+              ...subject ? { subject } : {},
+              reason: getString4(call.args.reason),
+              toolCallId: call.id,
+              assistantMessageIndex,
+              timestamp: timestamp2,
+              targetHint: resolveRecalledEntryHint(entryId, subject)
+            };
+            if (call.id) {
+              pendingAgentRetires.set(call.id, pending);
+            } else {
+              pendingAgentRetireQueue.push(pending);
+            }
             continue;
           }
-          const pending = {
-            entries,
-            toolCallId: call.id,
-            assistantMessageIndex,
-            timestamp: timestamp2
-          };
-          if (call.id) {
-            pendingAgentStores.set(call.id, pending);
-          } else {
-            pendingAgentStoreQueue.push(pending);
+          if (normalizedToolName === "agenr_update") {
+            const entryId = getString4(call.args.entry_id);
+            const subject = getString4(call.args.subject);
+            const importance = getNumber(call.args.importance);
+            const expiry = normalizeExpiry(getString4(call.args.expiry));
+            if (!entryId && !subject || entryId && subject || importance === void 0 && expiry === void 0) {
+              continue;
+            }
+            const pending = {
+              ...entryId ? { entryId } : {},
+              ...subject ? { subject } : {},
+              ...importance !== void 0 ? { importance } : {},
+              ...expiry !== void 0 ? { expiry } : {},
+              toolCallId: call.id,
+              assistantMessageIndex,
+              timestamp: timestamp2,
+              targetHint: resolveRecalledEntryHint(entryId, subject)
+            };
+            if (call.id) {
+              pendingAgentUpdates.set(call.id, pending);
+            } else {
+              pendingAgentUpdateQueue.push(pending);
+            }
           }
         }
         let text;
@@ -15308,8 +15750,17 @@ var openClawAdapter = {
         const normalizedToolName = toolName?.trim().toLowerCase();
         const args = ctx?.args ?? {};
         const toolText = normalizeMessageText(content);
+        const trimmedToolText = toolText.trim();
+        if (normalizedToolName === "agenr_recall") {
+          const recallFailed = message.isError === true || message.is_error === true || /^agenr_recall failed:/i.test(trimmedToolText);
+          if (!recallFailed) {
+            for (const hint of extractRecallTargetHints(message, toolText)) {
+              appendRecalledEntryHint(hint);
+            }
+          }
+        }
         if (normalizedToolName === "agenr_store") {
-          const storeFailed = message.isError === true || message.is_error === true || /^validation failed\b/i.test(toolText.trim());
+          const storeFailed = message.isError === true || message.is_error === true || /^validation failed\b/i.test(trimmedToolText);
           const pending = resolvePendingAgentStore(message, ctx?.id);
           if (pending && !storeFailed) {
             const toolResultMessageIndex = messages.length;
@@ -15331,6 +15782,39 @@ var openClawAdapter = {
             }
           }
         }
+        if (normalizedToolName === "agenr_retire") {
+          const retireFailed = message.isError === true || message.is_error === true || /^agenr_retire failed:/i.test(trimmedToolText);
+          const pending = resolvePendingAgentRetire(message, ctx?.id);
+          const receipt = parseRetireSuccessReceipt(toolText);
+          if (pending && !retireFailed && receipt && isRetireSuccessText(toolText)) {
+            const targetHint = pending.targetHint ?? resolveRecalledEntryHint(void 0, receipt.subject);
+            successfulAgentRetires.push({
+              entryId: receipt.entryId,
+              reason: pending.reason,
+              toolCallId: pending.toolCallId,
+              assistantMessageIndex: pending.assistantMessageIndex,
+              timestamp: pending.timestamp,
+              ...targetHint ? { targetHint } : {}
+            });
+          }
+        }
+        if (normalizedToolName === "agenr_update") {
+          const updateFailed = message.isError === true || message.is_error === true || /^agenr_update failed:/i.test(trimmedToolText) || isInactiveUpdateText(trimmedToolText);
+          const pending = resolvePendingAgentUpdate(message, ctx?.id);
+          const receipt = parseUpdateReceiptEntry(toolText);
+          if (pending && !updateFailed && receipt && isUpdateSuccessText(toolText)) {
+            const targetHint = pending.targetHint ?? resolveRecalledEntryHint(void 0, receipt.subject);
+            successfulAgentUpdates.push({
+              entryId: receipt.entryId,
+              ...pending.importance !== void 0 ? { importance: pending.importance } : {},
+              ...pending.expiry !== void 0 ? { expiry: pending.expiry } : {},
+              toolCallId: pending.toolCallId,
+              assistantMessageIndex: pending.assistantMessageIndex,
+              timestamp: pending.timestamp,
+              ...targetHint ? { targetHint } : {}
+            });
+          }
+        }
         if (!toolText) {
           return;
         }
@@ -15388,7 +15872,9 @@ var openClawAdapter = {
         startedAt: sessionTimestamp ?? messages[0]?.timestamp ?? fallbackTimestamp,
         agentStoreProjects: agentStoreProjects.size > 0 ? Array.from(agentStoreProjects) : void 0
       },
-      successfulAgentStoredEntries: successfulAgentStoredEntries.length > 0 ? successfulAgentStoredEntries : void 0
+      successfulAgentStoredEntries: successfulAgentStoredEntries.length > 0 ? successfulAgentStoredEntries : void 0,
+      successfulAgentRetires: successfulAgentRetires.length > 0 ? successfulAgentRetires : void 0,
+      successfulAgentUpdates: successfulAgentUpdates.length > 0 ? successfulAgentUpdates : void 0
     };
   }
 };
@@ -15853,7 +16339,9 @@ async function parseTranscriptFile(filePath, options) {
     chunks,
     warnings: result.warnings,
     metadata: result.metadata,
-    successfulAgentStoredEntries: result.successfulAgentStoredEntries
+    successfulAgentStoredEntries: result.successfulAgentStoredEntries,
+    successfulAgentRetires: result.successfulAgentRetires,
+    successfulAgentUpdates: result.successfulAgentUpdates
   };
 }
 
@@ -20281,18 +20769,6 @@ async function extractKnowledgeFromChunks(params) {
   };
 }
 
-// src/utils/expiry.ts
-init_types();
-var EXPIRY_SET = new Set(EXPIRY_LEVELS);
-var EXPIRY_PRIORITY = {
-  temporary: 0,
-  permanent: 1,
-  core: 2
-};
-function resolveHigherExpiry(a, b) {
-  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
-}
-
 // src/app/ingest/trigram-dedup.ts
 function normalize3(value) {
   return value.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -20660,8 +21136,8 @@ function createContradictionRepository(db) {
       });
       return result.rows.map((row) => {
         const record = row;
-        const importance = toNumber(record.importance);
-        const claimConfidence = toNumber(record.claim_confidence);
+        const importance = toNumber2(record.importance);
+        const claimConfidence = toNumber2(record.claim_confidence);
         const claimRole = toStringValue(record.claim_role);
         return {
           id: toStringValue(record.id),
@@ -25108,7 +25584,7 @@ async function queryCandidates(db, subject, contains) {
     id: toStringValue(row.id),
     type: toStringValue(row.type),
     subject: toStringValue(row.subject),
-    importance: toNumber(row.importance),
+    importance: toNumber2(row.importance),
     content: toStringValue(row.content)
   }));
 }
@@ -25125,7 +25601,7 @@ async function queryById(db, id) {
     id: toStringValue(row.id),
     type: toStringValue(row.type),
     subject: toStringValue(row.subject),
-    importance: toNumber(row.importance),
+    importance: toNumber2(row.importance),
     content: toStringValue(row.content)
   }));
 }
@@ -25201,12 +25677,16 @@ init_runtime2();
 function resolveUpdateServiceDeps(deps) {
   return resolveAppRuntimeDeps(deps);
 }
-function validateEntryId(id) {
-  const entryId = id?.trim() ?? "";
-  if (!entryId) {
-    throw new Error("id is required");
+function validateSelector2(request) {
+  const queryId = request.id?.trim() ?? "";
+  const querySubject = request.subject?.trim() ?? "";
+  if (!queryId && !querySubject) {
+    throw new Error("entry_id or subject is required");
   }
-  return entryId;
+  if (queryId && querySubject) {
+    throw new Error("entry_id and subject are mutually exclusive");
+  }
+  return { queryId, querySubject };
 }
 function normalizeImportance3(value) {
   const parsed = typeof value === "number" ? value : Number(value);
@@ -25215,10 +25695,26 @@ function normalizeImportance3(value) {
   }
   return parsed;
 }
+function normalizeOptionalImportance(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return normalizeImportance3(value);
+}
+function normalizeOptionalExpiry(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = normalizeExpiry(value);
+  if (!normalized) {
+    throw new Error(`expiry must be one of: ${EXPIRY_LEVELS.join(", ")}`);
+  }
+  return normalized;
+}
 async function queryById2(db, id) {
   const result = await db.execute({
     sql: `
-      SELECT id, type, subject, importance, content
+      SELECT id, type, subject, importance, expiry, content
       FROM entries
       WHERE retired = 0 AND id = ?
       LIMIT 1
@@ -25229,11 +25725,39 @@ async function queryById2(db, id) {
   if (!row) {
     return null;
   }
+  const expiry = normalizeExpiry(row.expiry) ?? "temporary";
   return {
     id: toStringValue(row.id),
     type: toStringValue(row.type),
     subject: toStringValue(row.subject),
-    importance: toNumber(row.importance),
+    importance: toNumber2(row.importance),
+    expiry,
+    content: toStringValue(row.content)
+  };
+}
+async function queryBySubject(db, subject) {
+  const result = await db.execute({
+    sql: `
+      SELECT id, type, subject, importance, expiry, content
+      FROM entries
+      WHERE retired = 0
+        AND LOWER(subject) = LOWER(?)
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `,
+    args: [subject]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  const expiry = normalizeExpiry(row.expiry) ?? "temporary";
+  return {
+    id: toStringValue(row.id),
+    type: toStringValue(row.type),
+    subject: toStringValue(row.subject),
+    importance: toNumber2(row.importance),
+    expiry,
     content: toStringValue(row.content)
   };
 }
@@ -25245,7 +25769,7 @@ async function lookupUpdateCandidate(request, deps) {
 }
 async function runUpdateService(request, deps) {
   const resolvedDeps = resolveUpdateServiceDeps(deps);
-  const id = validateEntryId(request.id);
+  const { queryId, querySubject } = validateSelector2(request);
   return withAppDb(
     {
       env: request.env,
@@ -25256,53 +25780,81 @@ async function runUpdateService(request, deps) {
       if (request.action === "lookup") {
         return {
           action: "lookup",
-          candidate: await queryById2(db, id)
+          candidate: queryId ? await queryById2(db, queryId) : await queryBySubject(db, querySubject)
         };
       }
-      const importance = normalizeImportance3(request.importance);
-      const existing = await queryById2(db, id);
+      const importance = normalizeOptionalImportance(request.importance);
+      const expiry = normalizeOptionalExpiry(request.expiry);
+      if (importance === void 0 && expiry === void 0) {
+        throw new Error("at least one of importance or expiry is required");
+      }
+      const existing = queryId ? await queryById2(db, queryId) : await queryBySubject(db, querySubject);
+      const targetId = existing?.id ?? queryId ?? querySubject;
       if (!existing) {
         return {
           action: "execute",
-          id,
-          previousImportance: importance,
-          importance,
+          id: targetId,
+          previousImportance: importance ?? IMPORTANCE_MIN,
+          importance: importance ?? IMPORTANCE_MIN,
+          previousExpiry: expiry ?? "temporary",
+          expiry: expiry ?? "temporary",
           updated: false
         };
       }
-      if (existing.importance === importance) {
+      const nextImportance = importance ?? existing.importance;
+      const nextExpiry = expiry ?? existing.expiry;
+      const importanceChanged = existing.importance !== nextImportance;
+      const expiryChanged = existing.expiry !== nextExpiry;
+      if (!importanceChanged && !expiryChanged) {
         return {
           action: "execute",
-          id,
+          id: existing.id,
           previousImportance: existing.importance,
-          importance,
+          importance: existing.importance,
+          previousExpiry: existing.expiry,
+          expiry: existing.expiry,
           updated: true
         };
       }
+      const setClauses = [];
+      const setArgs = [];
+      if (importanceChanged) {
+        setClauses.push("importance = ?");
+        setArgs.push(nextImportance);
+      }
+      if (expiryChanged) {
+        setClauses.push("expiry = ?");
+        setArgs.push(nextExpiry);
+      }
+      setClauses.push("updated_at = ?");
+      setArgs.push(runtime.now.toISOString());
       const result = await db.execute({
         sql: `
           UPDATE entries
-          SET importance = ?,
-              updated_at = ?
+          SET ${setClauses.join(", ")}
           WHERE id = ?
             AND retired = 0
         `,
-        args: [importance, runtime.now.toISOString(), id]
+        args: [...setArgs, existing.id]
       });
       if (toRowsAffected(result.rowsAffected) === 0) {
         return {
           action: "execute",
-          id,
+          id: existing.id,
           previousImportance: existing.importance,
           importance: existing.importance,
+          previousExpiry: existing.expiry,
+          expiry: existing.expiry,
           updated: false
         };
       }
       return {
         action: "execute",
-        id,
+        id: existing.id,
         previousImportance: existing.importance,
-        importance,
+        importance: nextImportance,
+        previousExpiry: existing.expiry,
+        expiry: nextExpiry,
         updated: true
       };
     }
@@ -25314,6 +25866,8 @@ async function executeUpdate(request, deps) {
     id: result.id,
     previousImportance: result.previousImportance,
     importance: result.importance,
+    previousExpiry: result.previousExpiry,
+    expiry: result.expiry,
     updated: result.updated
   };
 }
@@ -25325,8 +25879,8 @@ init_client();
 // src/db/provenance.ts
 init_entry_utils();
 function mapProvenanceEntry(row, tags) {
-  const importance = toNumber(row.importance);
-  const retired = toNumber(row.retired);
+  const importance = toNumber2(row.importance);
+  const retired = toNumber2(row.retired);
   return {
     id: toStringValue(row.id),
     subject: toStringValue(row.subject),
@@ -25349,7 +25903,7 @@ function mapProvenanceRelated(row, tags) {
   };
 }
 function mapProvenanceSupport(row) {
-  const claimConfidence = toNumber(row.claim_confidence);
+  const claimConfidence = toNumber2(row.claim_confidence);
   const sourceFile = toStringValue(row.source_file).trim();
   const sourceContext = toStringValue(row.source_context).trim();
   const sourceCreatedAt = toStringValue(row.source_created_at).trim();
@@ -26643,6 +27197,7 @@ function resolveOpenClawBridgeStoreProjectAttribution(params) {
 
 // src/openclaw-plugin/tools.ts
 init_types();
+init_project();
 var KNOWN_PLATFORMS = /* @__PURE__ */ new Set(["openclaw", "codex", "claude-code", "plaud"]);
 var log7 = createLogger("tools");
 var SUCCESSFUL_STORE_ACTIONS = /* @__PURE__ */ new Set([
@@ -26657,10 +27212,31 @@ function asString2(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function validateExclusiveSelector(params) {
+  const entryId = asString2(params.entry_id);
+  const subject = asString2(params.subject);
+  if (entryId && subject || !entryId && !subject) {
+    throw new Error("exactly one of entry_id or subject is required");
+  }
+  return { entryId, subject };
+}
+function formatQuotedSubject(subject) {
+  return JSON.stringify(subject);
+}
+function formatEntryLabel(id, subject) {
+  return subject ? `${id} (${formatQuotedSubject(subject)})` : id;
+}
+function formatMissingEntryError(selector) {
+  if (selector.subject) {
+    return `No active entry found matching subject: ${formatQuotedSubject(selector.subject)}`;
+  }
+  return `No active entry found with id: ${selector.entryId}`;
+}
 function resolveStoreCandidateProject(explicitProject, sessionProject, defaultProject) {
   return asString2(explicitProject) ?? asString2(sessionProject) ?? asString2(defaultProject);
 }
 function createAgentToolRecallScopeDiagnostic(scope, defaultProjectPresent) {
+  const diagnosticProjects = scope.projects.length > 0 ? scope.projects : scope.projectHints ?? [];
   return createProjectScopeResolutionDiagnostic({
     surface: "agent-tool-recall",
     inputs: {
@@ -26674,8 +27250,8 @@ function createAgentToolRecallScopeDiagnostic(scope, defaultProjectPresent) {
     outcome: {
       projectSource: scope.projectSource,
       reason: scope.reason,
-      projects: scope.projects,
-      primaryProject: scope.projects[0],
+      projects: diagnosticProjects,
+      primaryProject: diagnosticProjects[0],
       recallProjectArg: scope.recallProjectArg,
       strictScope: scope.projectStrict,
       dependencyExpansionApplied: false,
@@ -26685,7 +27261,9 @@ function createAgentToolRecallScopeDiagnostic(scope, defaultProjectPresent) {
 }
 function resolveAgentToolRecallScope(explicitProject, defaultProject) {
   const normalizedExplicitProject = explicitProject?.trim();
-  const defaultProjectPresent = Boolean(defaultProject?.trim());
+  const normalizedDefaultProjects = parseProjectList(defaultProject).filter((project) => project !== "*");
+  const normalizedDefaultProject = normalizedDefaultProjects[0];
+  const defaultProjectPresent = normalizedDefaultProjects.length > 0;
   if (normalizedExplicitProject === "*") {
     const scope2 = {
       surface: "agent-tool-recall",
@@ -26693,8 +27271,8 @@ function resolveAgentToolRecallScope(explicitProject, defaultProject) {
       projectSource: "unscoped",
       projectArgumentState: "wildcard",
       reason: "explicit-tool-project-bypass",
-      projects: [],
-      recallProjectArg: void 0,
+      projects: ["*"],
+      recallProjectArg: "*",
       projectStrict: false
     };
     return {
@@ -26706,14 +27284,34 @@ function resolveAgentToolRecallScope(explicitProject, defaultProject) {
     };
   }
   if (!normalizedExplicitProject) {
+    if (normalizedDefaultProject) {
+      const scope3 = {
+        surface: "agent-tool-recall",
+        projectResolutionMode: "explicit-tool-project-only",
+        projectSource: "plugin-default-project",
+        projectArgumentState: "omitted",
+        reason: "plugin-default-project",
+        projects: [],
+        projectHints: [normalizedDefaultProject],
+        recallProjectArg: void 0,
+        projectStrict: false
+      };
+      return {
+        ...scope3,
+        memoryReliabilityDiagnostic: createAgentToolRecallScopeDiagnostic(
+          scope3,
+          defaultProjectPresent
+        )
+      };
+    }
     const scope2 = {
       surface: "agent-tool-recall",
       projectResolutionMode: "explicit-tool-project-only",
       projectSource: "unscoped",
       projectArgumentState: "omitted",
       reason: "no-project-candidate",
-      projects: [],
-      recallProjectArg: void 0,
+      projects: ["*"],
+      recallProjectArg: "*",
       projectStrict: false
     };
     return {
@@ -26755,6 +27353,36 @@ function asNumber(value) {
   }
   return void 0;
 }
+function normalizeOptionalUpdateExpiry(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const expiry = normalizeExpiry(value);
+  if (!expiry) {
+    throw new Error(`expiry must be one of: ${EXPIRY_LEVELS.join(", ")}`);
+  }
+  return expiry;
+}
+function buildChangedUpdateParts(request, result) {
+  const parts = [];
+  if (request.importance !== void 0 && result.previousImportance !== result.importance) {
+    parts.push(`importance ${result.previousImportance} \u2192 ${result.importance}`);
+  }
+  if (request.expiry !== void 0 && result.previousExpiry !== result.expiry) {
+    parts.push(`expiry ${result.previousExpiry} \u2192 ${result.expiry}`);
+  }
+  return parts;
+}
+function buildRequestedUpdateParts(request, result) {
+  const parts = [];
+  if (request.importance !== void 0) {
+    parts.push(`importance ${result.importance}`);
+  }
+  if (request.expiry !== void 0) {
+    parts.push(`expiry ${result.expiry}`);
+  }
+  return parts;
+}
 function parseOptionalPositiveInt(value, label) {
   if (value === void 0) {
     return void 0;
@@ -26879,6 +27507,7 @@ async function runRecallTool(params, defaultProject, dbPath) {
         platform: normalizeRecallPlatform(asString2(params.platform)),
         project: recallScope.projects,
         projectStrict: recallScope.projectStrict,
+        projectHints: recallScope.projectHints,
         budget: null
       },
       dbPath,
@@ -27069,34 +27698,34 @@ async function runExtractTool(params, dbPath) {
 }
 async function runRetireTool(params, dbPath) {
   try {
-    const entryId = asString2(params.entry_id);
-    if (!entryId) {
-      return {
-        content: [{ type: "text", text: "agenr_retire failed: entry_id is required" }]
-      };
-    }
+    const selector = validateExclusiveSelector(params);
     const lookup = await lookupRetireCandidates({
-      id: entryId,
+      id: selector.entryId,
+      subject: selector.subject,
       dbPath
     });
-    if (lookup.candidates.length === 0) {
+    const candidate = lookup.candidates[0];
+    if (!candidate) {
       return {
-        content: [{ type: "text", text: `agenr_retire failed: No active entry found with id: ${entryId}` }]
+        content: [{ type: "text", text: `agenr_retire failed: ${formatMissingEntryError(selector)}` }]
       };
     }
     const retired = await executeRetire({
-      id: entryId,
+      id: candidate.id,
       reason: asString2(params.reason),
       persist: params.persist === true,
       dbPath
     });
     if (retired.retiredCount === 0) {
       return {
-        content: [{ type: "text", text: `agenr_retire failed: No active entry found with id: ${entryId}` }]
+        content: [{ type: "text", text: `agenr_retire failed: ${formatMissingEntryError(selector)}` }]
       };
     }
     return {
-      content: [{ type: "text", text: `Retired entry ${entryId}.` }]
+      content: [{
+        type: "text",
+        text: `Retired entry ${formatEntryLabel(candidate.id, selector.subject ? candidate.subject : void 0)}.`
+      }]
     };
   } catch (error) {
     return {
@@ -27106,42 +27735,60 @@ async function runRetireTool(params, dbPath) {
 }
 async function runUpdateTool(params, dbPath) {
   try {
-    const entryId = asString2(params.entry_id);
+    const selector = validateExclusiveSelector(params);
+    const importanceProvided = Object.prototype.hasOwnProperty.call(params, "importance");
     const importance = asNumber(params.importance);
-    if (!entryId) {
+    if (importanceProvided && (importance === void 0 || !Number.isInteger(importance) || importance < 1 || importance > 10)) {
       return {
-        content: [{ type: "text", text: "agenr_update failed: entry_id is required" }]
+        content: [{ type: "text", text: "agenr_update failed: importance must be an integer between 1 and 10" }]
       };
     }
-    if (typeof importance !== "number" || !Number.isInteger(importance) || importance < 1 || importance > 10) {
+    const expiry = normalizeOptionalUpdateExpiry(params.expiry);
+    if (importance === void 0 && expiry === void 0) {
       return {
-        content: [{ type: "text", text: "agenr_update failed: importance must be an integer between 1 and 10" }]
+        content: [{ type: "text", text: "agenr_update failed: at least one of importance or expiry is required" }]
       };
     }
     const lookup = await lookupUpdateCandidate({
-      id: entryId,
+      id: selector.entryId,
+      subject: selector.subject,
       dbPath
     });
-    if (!lookup.candidate) {
+    const candidate = lookup.candidate;
+    if (!candidate) {
       return {
-        content: [{ type: "text", text: `agenr_update failed: No active entry found with id: ${entryId}` }]
+        content: [{ type: "text", text: `agenr_update failed: ${formatMissingEntryError(selector)}` }]
       };
     }
     const updated = await executeUpdate({
-      id: entryId,
-      importance,
+      id: candidate.id,
+      ...importance !== void 0 ? { importance } : {},
+      ...expiry !== void 0 ? { expiry } : {},
       dbPath
     });
+    const entryLabel = formatEntryLabel(candidate.id, selector.subject ? candidate.subject : void 0);
     if (!updated.updated) {
       return {
-        content: [{ type: "text", text: `Entry ${entryId} was not updated because it is no longer active.` }]
+        content: [{ type: "text", text: `Entry ${entryLabel} was not updated because it is no longer active.` }]
+      };
+    }
+    const changedParts = buildChangedUpdateParts({ importance, expiry }, updated);
+    if (changedParts.length > 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Updated entry ${entryLabel}: ${changedParts.join(", ")}.`
+          }
+        ]
       };
     }
+    const requestedParts = buildRequestedUpdateParts({ importance, expiry }, updated);
     return {
       content: [
         {
           type: "text",
-          text: updated.previousImportance === updated.importance ? `Entry ${entryId} already has importance ${updated.importance}.` : `Updated entry ${entryId} importance: ${updated.previousImportance} -> ${updated.importance}.`
+          text: requestedParts.length === 1 ? `Entry ${entryLabel} already has ${requestedParts[0]}.` : `Entry ${entryLabel} already has ${requestedParts.join(" and ")}.`
         }
       ]
     };
@@ -32721,11 +33368,7 @@ async function runClearSessionProjectTool(sessionKey, pluginConfig) {
 }
 
 // src/openclaw-plugin/hooks/register-tools.ts
-var EXPIRY_SCHEMA = Type6.Union([
-  Type6.Literal("core"),
-  Type6.Literal("permanent"),
-  Type6.Literal("temporary")
-]);
+var EXPIRY_SCHEMA = Type6.String({ enum: ["core", "permanent", "temporary"] });
 function optionalExpirySchema(description) {
   return Type6.Optional({
     ...EXPIRY_SCHEMA,
@@ -32771,12 +33414,10 @@ function registerAgenrTools(api, params) {
       parameters: Type6.Object({
         query: Type6.Optional(Type6.String({ description: "What to search for." })),
         context: Type6.Optional(
-          Type6.Union(
-            [Type6.Literal("default"), Type6.Literal("session-start"), Type6.Literal("browse")],
-            {
-              description: "Use session-start for fast bootstrap without embedding. Use browse for temporal browsing (date+importance, no query needed, no semantic search)."
-            }
-          )
+          Type6.String({
+            enum: ["default", "session-start", "browse"],
+            description: "Use session-start for fast bootstrap without embedding. Use browse for recency-dominant temporal browsing with secondary importance tie-breaking (no query needed, no semantic search)."
+          })
         ),
         limit: Type6.Optional(Type6.Number({ description: "Max results (default: 10)." })),
         types: Type6.Optional(Type6.String({ description: "Comma-separated entry types to filter." })),
@@ -32803,7 +33444,8 @@ function registerAgenrTools(api, params) {
           return makeDisabledToolResult();
         }
         const dbPath = runtimeConfig?.dbPath;
-        const result = await runRecallTool(toolParams, void 0, dbPath);
+        const defaultProject = runtimeConfig?.project?.trim() || void 0;
+        const result = await runRecallTool(toolParams, defaultProject, dbPath);
         const sessionKey = sessionRef.current;
         if (sessionKey && result.agentToolRecallSurface) {
           const addedCount = createSessionSurfacedMemoryService(sessionKey).recordByIntent(
@@ -32992,11 +33634,22 @@ function registerAgenrTools(api, params) {
       name: "agenr_retire",
       label: "Agenr Retire",
       description: "Mark a memory entry as retired (soft delete). Retired entries are excluded from all recall.",
-      parameters: Type6.Object({
-        entry_id: Type6.String({ description: "Entry ID to retire." }),
-        reason: Type6.Optional(Type6.String({ description: "Retirement reason." })),
-        persist: Type6.Optional(Type6.Boolean({ description: "Persist retirement to ledger." }))
-      }),
+      parameters: Type6.Object(
+        {
+          entry_id: Type6.Optional(Type6.String({ description: "Entry ID to retire." })),
+          subject: Type6.Optional(
+            Type6.String({ description: "Subject string to match. Mutually exclusive with entry_id." })
+          ),
+          reason: Type6.Optional(Type6.String({ description: "Retirement reason." })),
+          persist: Type6.Optional(Type6.Boolean({ description: "Persist retirement to ledger." }))
+        },
+        {
+          anyOf: [
+            { required: ["entry_id"] },
+            { required: ["subject"] }
+          ]
+        }
+      ),
       async execute(_toolCallId, toolParams) {
         const runtimeConfig = api.pluginConfig;
         if (runtimeConfig?.enabled === false) {
@@ -33011,11 +33664,37 @@ function registerAgenrTools(api, params) {
     {
       name: "agenr_update",
       label: "Agenr Update",
-      description: "Update an existing memory entry in place. Currently supports importance only.",
-      parameters: Type6.Object({
-        entry_id: Type6.String({ description: "Entry ID to update." }),
-        importance: Type6.Integer({ minimum: 1, maximum: 10, description: "New importance score." })
-      }),
+      description: "Update an existing memory entry in place. Currently supports importance and expiry.",
+      parameters: Type6.Object(
+        {
+          entry_id: Type6.Optional(Type6.String({ description: "Entry ID to update." })),
+          subject: Type6.Optional(
+            Type6.String({
+              description: "Subject string to match. Mutually exclusive with entry_id."
+            })
+          ),
+          importance: Type6.Optional(
+            Type6.Integer({ minimum: 1, maximum: 10, description: "New importance score." })
+          ),
+          expiry: optionalExpirySchema("New expiry tier: core, permanent, or temporary.")
+        },
+        {
+          allOf: [
+            {
+              anyOf: [
+                { required: ["entry_id"] },
+                { required: ["subject"] }
+              ]
+            },
+            {
+              anyOf: [
+                { required: ["importance"] },
+                { required: ["expiry"] }
+              ]
+            }
+          ]
+        }
+      ),
       async execute(_toolCallId, toolParams) {
         const runtimeConfig = api.pluginConfig;
         if (runtimeConfig?.enabled === false) {