@agenr/openclaw-plugin 0.13.4 → 0.14.1

package/dist/index.js

@@ -827,6 +827,9 @@ function formatShadowMismatch(stats) {
   }
   return details.join(", ");
 }
+function formatIntegrityDetail(embeddingCount, shadowCount, missingRowids) {
+  return `active=${embeddingCount}, shadow=${shadowCount}, missing=${missingRowids}`;
+}
 async function rollbackQuietly(db) {
   try {
     await db.execute("ROLLBACK");
@@ -919,6 +922,18 @@ async function getVectorIndexShadowStats(db) {
     missingRowids
   };
 }
+async function checkVectorIntegrity(db) {
+  const stats = await getVectorIndexShadowStats(db);
+  const missingRowids = stats.missingRowids.length;
+  return {
+    drifted: stats.embeddingCount !== stats.shadowCount || missingRowids > 0,
+    detail: formatIntegrityDetail(stats.embeddingCount, stats.shadowCount, missingRowids),
+    activeEntries: stats.embeddingCount,
+    shadowRows: stats.shadowCount,
+    missingRowids,
+    missingRowidValues: stats.missingRowids
+  };
+}
 async function rebuildVectorIndex(db, options) {
   const start = Date.now();
   const onLog = options?.onLog ?? (() => void 0);
@@ -1088,6 +1103,287 @@ var init_version = __esm({
   }
 });
 
+// src/shared/utils/entry-utils.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;
+}
+function toStringValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return String(value);
+  }
+  return "";
+}
+function toRowsAffected(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    return Number(value);
+  }
+  return 0;
+}
+function parseDaysBetween(now, pastIso) {
+  if (!pastIso) {
+    return 0;
+  }
+  const parsed = new Date(pastIso);
+  if (Number.isNaN(parsed.getTime())) {
+    return 0;
+  }
+  const delta = (now.getTime() - parsed.getTime()) / MILLISECONDS_PER_DAY;
+  if (!Number.isFinite(delta)) {
+    return 0;
+  }
+  return Math.max(delta, 0);
+}
+var MILLISECONDS_PER_DAY;
+var init_entry_utils = __esm({
+  "src/shared/utils/entry-utils.ts"() {
+    "use strict";
+    MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
+  }
+});
+
+// src/shared/infrastructure/db/co-recall.ts
+function normalizePair(a, b) {
+  return a < b ? [a, b] : [b, a];
+}
+async function strengthenEdges(db, usedEntryIds, timestamp2, edgeType) {
+  const uniqueIds = Array.from(
+    new Set(
+      usedEntryIds.map((id) => id.trim()).filter((id) => id.length > 0)
+    )
+  ).slice(0, MAX_USED_ENTRIES);
+  if (uniqueIds.length < 2) {
+    return;
+  }
+  const now = timestamp2 || (/* @__PURE__ */ new Date()).toISOString();
+  const pairs = [];
+  for (let i = 0; i < uniqueIds.length; i += 1) {
+    const a = uniqueIds[i];
+    if (!a) {
+      continue;
+    }
+    for (let j = i + 1; j < uniqueIds.length; j += 1) {
+      const b = uniqueIds[j];
+      if (!b || a === b) {
+        continue;
+      }
+      pairs.push(normalizePair(a, b));
+    }
+  }
+  if (pairs.length === 0) {
+    return;
+  }
+  await db.execute("BEGIN");
+  try {
+    for (const [entryA, entryB] of pairs) {
+      await db.execute({
+        sql: `
+          INSERT INTO co_recall_edges (
+            entry_a, entry_b, edge_type, weight, session_count, last_co_recalled, created_at
+          )
+          VALUES (?, ?, ?, ?, 1, ?, ?)
+          ON CONFLICT
+          DO UPDATE SET
+            weight = MIN(co_recall_edges.weight + excluded.weight, 1.0),
+            session_count = co_recall_edges.session_count + 1,
+            last_co_recalled = excluded.last_co_recalled
+        `,
+        args: [
+          entryA,
+          entryB,
+          edgeType,
+          DEFAULT_EDGE_INCREMENT,
+          now,
+          now
+        ]
+      });
+    }
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function strengthenCoRecallEdges(db, usedEntryIds, timestamp2) {
+  await strengthenEdges(db, usedEntryIds, timestamp2, CO_RECALL_EDGE_TYPE);
+}
+async function getCoRecallNeighbors(db, entryId, minWeight = 0.1, limit = 10, edgeType = CO_RECALL_EDGE_TYPE) {
+  const normalizedId = entryId.trim();
+  if (!normalizedId) {
+    return [];
+  }
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
+  const safeMinWeight = Number.isFinite(minWeight) ? Math.max(minWeight, 0) : 0.1;
+  const result = await db.execute({
+    sql: `
+      SELECT
+        CASE WHEN entry_a = ? THEN entry_b ELSE entry_a END AS neighbor_id,
+        weight,
+        session_count,
+        last_co_recalled
+      FROM co_recall_edges
+      WHERE edge_type = ?
+        AND (entry_a = ? OR entry_b = ?)
+        AND weight >= ?
+      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
+      LIMIT ?
+    `,
+    args: [normalizedId, edgeType, normalizedId, normalizedId, safeMinWeight, safeLimit]
+  });
+  return result.rows.map((row) => ({
+    entryId: toStringValue(row.neighbor_id),
+    weight: toNumber2(row.weight),
+    sessionCount: toNumber2(row.session_count),
+    lastCoRecalled: toStringValue(row.last_co_recalled)
+  }));
+}
+async function getCoRecallEdgeCounts(db, edgeType = CO_RECALL_EDGE_TYPE) {
+  const result = await db.execute({
+    sql: `
+      SELECT entry_id, COUNT(*) AS edge_count
+      FROM (
+        SELECT entry_a AS entry_id
+        FROM co_recall_edges
+        WHERE edge_type = ?
+        UNION ALL
+        SELECT entry_b AS entry_id
+        FROM co_recall_edges
+        WHERE edge_type = ?
+      )
+      GROUP BY entry_id
+    `,
+    args: [edgeType, edgeType]
+  });
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const entryId = toStringValue(row.entry_id).trim();
+    if (!entryId) {
+      continue;
+    }
+    counts.set(entryId, Math.max(0, toNumber2(row.edge_count)));
+  }
+  return counts;
+}
+async function getTopCoRecallEdges(db, limit = 20, edgeType = CO_RECALL_EDGE_TYPE) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+  const result = await db.execute({
+    sql: `
+      SELECT entry_a, entry_b, weight, session_count, last_co_recalled
+      FROM co_recall_edges
+      WHERE edge_type = ?
+      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
+      LIMIT ?
+    `,
+    args: [edgeType, safeLimit]
+  });
+  return result.rows.map((row) => ({
+    entryA: toStringValue(row.entry_a),
+    entryB: toStringValue(row.entry_b),
+    weight: toNumber2(row.weight),
+    sessionCount: toNumber2(row.session_count),
+    lastCoRecalled: toStringValue(row.last_co_recalled)
+  }));
+}
+var DEFAULT_EDGE_INCREMENT, MAX_USED_ENTRIES, CO_RECALL_EDGE_TYPE, CO_INGEST_EDGE_TYPE, ALL_EDGE_TYPES, ALL_EDGE_TYPES_PLACEHOLDERS;
+var init_co_recall = __esm({
+  "src/shared/infrastructure/db/co-recall.ts"() {
+    "use strict";
+    init_entry_utils();
+    DEFAULT_EDGE_INCREMENT = 0.1;
+    MAX_USED_ENTRIES = 20;
+    CO_RECALL_EDGE_TYPE = "co_recalled";
+    CO_INGEST_EDGE_TYPE = "co_ingested";
+    ALL_EDGE_TYPES = [CO_RECALL_EDGE_TYPE, CO_INGEST_EDGE_TYPE];
+    ALL_EDGE_TYPES_PLACEHOLDERS = ALL_EDGE_TYPES.map(() => "?").join(", ");
+  }
+});
+
+// src/shared/infrastructure/db/meta.ts
+function normalizeIsoTimestamp(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid ISO timestamp: ${value}`);
+  }
+  return new Date(parsed).toISOString();
+}
+async function getMetaValue(db, key) {
+  const result = await db.execute({
+    sql: "SELECT value FROM _meta WHERE key = ? LIMIT 1",
+    args: [key]
+  });
+  const raw = result.rows[0];
+  const value = raw?.value ?? (raw ? Object.values(raw)[0] : void 0);
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+async function setMetaValue(db, input) {
+  const updatedAt = normalizeIsoTimestamp(input.updatedAt ?? /* @__PURE__ */ new Date());
+  await db.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `,
+    args: [input.key, input.value, updatedAt]
+  });
+}
+async function getLastCorpusRebuildAt(db) {
+  return getMetaValue(db, LAST_CORPUS_REBUILD_AT_META_KEY);
+}
+async function setLastCorpusRebuildAt(db, value) {
+  const normalized = normalizeIsoTimestamp(value);
+  await setMetaValue(db, {
+    key: LAST_CORPUS_REBUILD_AT_META_KEY,
+    value: normalized,
+    updatedAt: normalized
+  });
+}
+async function initializeLastCorpusRebuildAtForEmptyCorpus(db, at = /* @__PURE__ */ new Date()) {
+  const existing = await getLastCorpusRebuildAt(db);
+  if (existing) {
+    return;
+  }
+  const result = await db.execute("SELECT COUNT(*) AS count FROM entries");
+  const count = Number(result.rows[0]?.count ?? 0);
+  if (count > 0) {
+    return;
+  }
+  await setLastCorpusRebuildAt(db, at);
+}
+var LAST_CORPUS_REBUILD_AT_META_KEY;
+var init_meta = __esm({
+  "src/shared/infrastructure/db/meta.ts"() {
+    "use strict";
+    LAST_CORPUS_REBUILD_AT_META_KEY = "last_corpus_rebuild_at";
+  }
+});
+
 // src/shared/infrastructure/db/migrations/reflection-importance-cap.ts
 async function applyReflectionImportanceCapMigration(db) {
   await db.execute("BEGIN IMMEDIATE");
@@ -1602,25 +1898,55 @@ async function backfillLegacyImportanceFromConfidence(client) {
   } catch {
   }
 }
-async function stampSchemaMetadata(client) {
+async function retypeLegacyCoRecallEdges(client) {
+  const edgeInfo = await client.execute("PRAGMA table_info(co_recall_edges)");
+  const edgeColumns = readColumnNames(edgeInfo.rows);
+  if (!edgeColumns.has("edge_type")) {
+    return;
+  }
+  const sentinel = await client.execute({
+    sql: "SELECT 1 AS found FROM _meta WHERE key = ? LIMIT 1",
+    args: [CO_INGEST_EDGE_RETYPE_META_KEY]
+  });
+  if (sentinel.rows.length > 0) {
+    return;
+  }
   await client.execute({
     sql: `
-      INSERT INTO _meta (key, value, updated_at)
-      VALUES ('db_created_at', datetime('now'), datetime('now'))
-      ON CONFLICT(key) DO NOTHING
+      UPDATE co_recall_edges
+      SET edge_type = ?
+      WHERE edge_type = ?
     `,
-    args: []
+    args: [CO_INGEST_EDGE_TYPE, CO_RECALL_EDGE_TYPE]
   });
   await client.execute({
     sql: `
       INSERT INTO _meta (key, value, updated_at)
-      VALUES ('schema_version', ?, datetime('now'))
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+      VALUES (?, datetime('now'), datetime('now'))
+      ON CONFLICT(key) DO NOTHING
     `,
-    args: [APP_VERSION]
+    args: [CO_INGEST_EDGE_RETYPE_META_KEY]
   });
 }
-async function repairVectorIndexIfNeeded(client) {
+async function stampSchemaMetadata(client) {
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('db_created_at', datetime('now'), datetime('now'))
+      ON CONFLICT(key) DO NOTHING
+    `,
+    args: []
+  });
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('schema_version', ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `,
+    args: [APP_VERSION]
+  });
+}
+async function repairVectorIndexIfNeeded(client) {
   try {
     const hasEntries = await client.execute(
       "SELECT 1 FROM entries WHERE embedding IS NOT NULL AND retired = 0 AND superseded_by IS NULL LIMIT 1"
@@ -1658,17 +1984,21 @@ async function initSchema(client) {
   await applyReflectionImportanceCapMigration(client);
   await applyReflectionRemovalMigration(client);
   await backfillLegacyImportanceFromConfidence(client);
+  await retypeLegacyCoRecallEdges(client);
   for (const statement of CREATE_INDEX_STATEMENTS) {
     await client.execute(statement);
   }
   await repairVectorIndexIfNeeded(client);
   await stampSchemaMetadata(client);
+  await initializeLastCorpusRebuildAtForEmptyCorpus(client);
 }
-var LEGACY_IMPORTANCE_BACKFILL_META_KEY;
+var LEGACY_IMPORTANCE_BACKFILL_META_KEY, CO_INGEST_EDGE_RETYPE_META_KEY;
 var init_init = __esm({
   "src/shared/infrastructure/db/schema/init.ts"() {
     "use strict";
     init_version();
+    init_co_recall();
+    init_meta();
     init_reflection_importance_cap();
     init_reflection_removal();
     init_vector_index();
@@ -1677,6 +2007,7 @@ var init_init = __esm({
     init_fts();
     init_recall_events();
     LEGACY_IMPORTANCE_BACKFILL_META_KEY = "legacy_importance_backfill_from_confidence_v1";
+    CO_INGEST_EDGE_RETYPE_META_KEY = "co_recall_edges_retyped_to_co_ingested_v1";
   }
 });
 
@@ -2039,6 +2370,52 @@ var init_client = __esm({
   }
 });
 
+// src/shared/domain/types.ts
+var KNOWLEDGE_TYPES, IMPORTANCE_MIN, IMPORTANCE_MAX, EXPIRY_LEVELS, SCOPE_LEVELS, KNOWLEDGE_PLATFORMS, REJECTED_CONFLICT_ENTRY_ID;
+var init_types = __esm({
+  "src/shared/domain/types.ts"() {
+    "use strict";
+    KNOWLEDGE_TYPES = [
+      "fact",
+      "decision",
+      "preference",
+      "todo",
+      "relationship",
+      "event",
+      "lesson",
+      "reflection"
+    ];
+    IMPORTANCE_MIN = 1;
+    IMPORTANCE_MAX = 10;
+    EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+    SCOPE_LEVELS = ["private", "personal", "public"];
+    KNOWLEDGE_PLATFORMS = ["openclaw", "claude-code", "codex", "plaud"];
+    REJECTED_CONFLICT_ENTRY_ID = "rejected";
+  }
+});
+
+// src/shared/domain/subject-key.ts
+function isGenericSubjectKey(subjectKey2, entryType) {
+  const normalizedSubjectKey = subjectKey2?.trim().toLowerCase();
+  const normalizedEntryType = entryType.trim().toLowerCase();
+  if (!normalizedSubjectKey || !normalizedEntryType || !ENTRY_TYPE_ATTRIBUTES.has(normalizedEntryType)) {
+    return false;
+  }
+  const slashIndex = normalizedSubjectKey.lastIndexOf("/");
+  if (slashIndex < 0 || slashIndex === normalizedSubjectKey.length - 1) {
+    return false;
+  }
+  return normalizedSubjectKey.slice(slashIndex + 1) === normalizedEntryType;
+}
+var ENTRY_TYPE_ATTRIBUTES;
+var init_subject_key = __esm({
+  "src/shared/domain/subject-key.ts"() {
+    "use strict";
+    init_types();
+    ENTRY_TYPE_ATTRIBUTES = new Set(KNOWLEDGE_TYPES);
+  }
+});
+
 // src/modules/store/domain/structured-claim.ts
 function normalizeLower(value) {
   return value?.trim().toLowerCase() ?? "";
@@ -2256,6 +2633,34 @@ function buildSubjectKey(subjectEntity, subjectAttribute, fallback) {
   }
   return fallback;
 }
+function extractTopicSlug(text) {
+  if (!text || text.trim().length === 0) {
+    return null;
+  }
+  const tokens = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((token) => token.length > 1 && !TOPIC_SLUG_STOP_WORDS.has(token));
+  const slug = tokens.slice(0, TOPIC_SLUG_MAX_TOKENS).join("_").slice(0, TOPIC_SLUG_MAX_LENGTH);
+  return slug.length >= TOPIC_SLUG_MIN_LENGTH ? slug : null;
+}
+function deriveTopicAttribute(entry, fallback) {
+  const normalizedFallback = normalizeLower(fallback);
+  const normalizedType = normalizeLower(entry.type);
+  const objectSlug = extractTopicSlug(entry.claimObject);
+  if (objectSlug && objectSlug !== normalizedFallback && objectSlug !== normalizedType) {
+    return objectSlug;
+  }
+  const subjectSlug = extractTopicSlug(entry.subject);
+  if (subjectSlug && subjectSlug !== normalizedFallback && subjectSlug !== normalizedType) {
+    return subjectSlug;
+  }
+  return fallback;
+}
+function resolveSubjectAttribute(entry, subjectEntity, subjectAttribute, fallbackSubjectKey) {
+  const subjectKey2 = buildSubjectKey(subjectEntity, subjectAttribute, fallbackSubjectKey);
+  if (!isGenericSubjectKey(subjectKey2, entry.type)) {
+    return subjectAttribute;
+  }
+  return deriveTopicAttribute(entry, subjectAttribute);
+}
 function normalizeStructuredClaimFields(entry) {
   const normalizedSubjectEntity = normalizeLower(entry.subjectEntity);
   const normalizedSubjectKey = normalizeLower(entry.subjectKey);
@@ -2272,6 +2677,16 @@ function normalizeStructuredClaimFields(entry) {
     claimRole: entry.claimRole
   });
   const normalizedAttribute = detectedState.normalizedAttribute ?? subjectAttribute;
+  const resolvedAttribute = resolveSubjectAttribute(
+    {
+      type: entry.type,
+      subject: entry.subject,
+      claimObject: entry.claimObject
+    },
+    subjectEntity,
+    normalizedAttribute,
+    normalizedSubjectKey
+  );
   const transitionClaim = detectedState.role ? void 0 : detectTransitionClaim({
     content: entry.content,
     claimObject: entry.claimObject,
@@ -2280,11 +2695,11 @@ function normalizeStructuredClaimFields(entry) {
   if (subjectEntity) {
     entry.subjectEntity = subjectEntity;
   }
-  if (normalizedAttribute) {
-    entry.subjectAttribute = normalizedAttribute;
+  if (resolvedAttribute) {
+    entry.subjectAttribute = resolvedAttribute;
   }
-  if (subjectEntity || normalizedAttribute) {
-    entry.subjectKey = buildSubjectKey(subjectEntity, normalizedAttribute, normalizedSubjectKey);
+  if (subjectEntity || resolvedAttribute) {
+    entry.subjectKey = buildSubjectKey(subjectEntity, resolvedAttribute, normalizedSubjectKey);
   }
   if (transitionClaim) {
     entry.claimPredicate = STATE_TRANSITION_PREDICATE;
@@ -2330,10 +2745,11 @@ function buildStructuredClaimIdentity(entry) {
     cardinality: "exact_value_only"
   };
 }
-var STRUCTURED_CLAIM_IDENTITY_TYPES, STRUCTURED_CLAIM_CONFIDENCE_FLOOR, STATE_ANCHOR_PREDICATE, STATE_TRANSITION_PREDICATE, DECISION_COMMITMENT_MARKERS, DECISION_NON_COMMITMENT_MARKERS, EXPLICIT_STATE_ROLE_SUFFIXES, CURRENT_STATE_SUBJECT_MARKERS, PRIOR_STATE_SUBJECT_MARKERS, CURRENT_STATE_CONTENT_MARKERS, PRIOR_STATE_CONTENT_MARKERS, STATE_NON_COMMITMENT_MARKERS, TRANSITION_PATTERNS, TRANSITION_MULTI_STEP_MARKERS;
+var STRUCTURED_CLAIM_IDENTITY_TYPES, STRUCTURED_CLAIM_CONFIDENCE_FLOOR, STATE_ANCHOR_PREDICATE, STATE_TRANSITION_PREDICATE, DECISION_COMMITMENT_MARKERS, DECISION_NON_COMMITMENT_MARKERS, EXPLICIT_STATE_ROLE_SUFFIXES, CURRENT_STATE_SUBJECT_MARKERS, PRIOR_STATE_SUBJECT_MARKERS, CURRENT_STATE_CONTENT_MARKERS, PRIOR_STATE_CONTENT_MARKERS, STATE_NON_COMMITMENT_MARKERS, TRANSITION_PATTERNS, TRANSITION_MULTI_STEP_MARKERS, TOPIC_SLUG_STOP_WORDS, TOPIC_SLUG_MAX_TOKENS, TOPIC_SLUG_MAX_LENGTH, TOPIC_SLUG_MIN_LENGTH;
 var init_structured_claim = __esm({
   "src/modules/store/domain/structured-claim.ts"() {
     "use strict";
+    init_subject_key();
     STRUCTURED_CLAIM_IDENTITY_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "decision"]);
     STRUCTURED_CLAIM_CONFIDENCE_FLOOR = 0.8;
     STATE_ANCHOR_PREDICATE = "state_is";
@@ -2427,6 +2843,48 @@ var init_structured_claim = __esm({
       /\bafter that\b/i,
       /\bthen\b.{0,24}\b(?:move|moved|switch|switched|replace|replaced|migrate|migrated|transition|transitioned)\b/i
     ];
+    TOPIC_SLUG_STOP_WORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "for",
+      "and",
+      "or",
+      "to",
+      "in",
+      "of",
+      "on",
+      "at",
+      "by",
+      "with",
+      "from",
+      "that",
+      "this",
+      "is",
+      "was",
+      "are",
+      "were",
+      "be",
+      "been",
+      "has",
+      "have",
+      "had",
+      "it",
+      "its",
+      "create",
+      "creating",
+      "document",
+      "documenting",
+      "turn",
+      "turning",
+      "into",
+      "concrete",
+      "investigate",
+      "investigating"
+    ]);
+    TOPIC_SLUG_MAX_TOKENS = 6;
+    TOPIC_SLUG_MAX_LENGTH = 60;
+    TOPIC_SLUG_MIN_LENGTH = 3;
   }
 });
 
@@ -2706,212 +3164,274 @@ var init_client2 = __esm({
   }
 });
 
-// src/shared/utils/entry-utils.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;
-}
-function toStringValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "bigint") {
-    return String(value);
+// src/shared/infrastructure/config/schema.ts
+import os3 from "os";
+import path3 from "path";
+function resolveClaimExtractionBatchSize(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE;
   }
-  return "";
+  return Math.min(Math.floor(value), MAX_CLAIM_EXTRACTION_BATCH_SIZE);
 }
-function toRowsAffected(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return Number(value);
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    return Number(value);
+function resolveClaimExtractionConcurrency(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
   }
-  return 0;
+  return Math.min(Math.floor(value), MAX_CLAIM_EXTRACTION_CONCURRENCY);
 }
-function parseDaysBetween(now, pastIso) {
-  if (!pastIso) {
-    return 0;
-  }
-  const parsed = new Date(pastIso);
-  if (Number.isNaN(parsed.getTime())) {
-    return 0;
-  }
-  const delta = (now.getTime() - parsed.getTime()) / MILLISECONDS_PER_DAY;
-  if (!Number.isFinite(delta)) {
-    return 0;
-  }
-  return Math.max(delta, 0);
+function isModelTask(value) {
+  return MODEL_TASK_KEYS.includes(value);
 }
-var MILLISECONDS_PER_DAY;
-var init_entry_utils = __esm({
-  "src/shared/utils/entry-utils.ts"() {
-    "use strict";
-    MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
-  }
-});
-
-// src/shared/infrastructure/db/co-recall.ts
-function normalizePair(a, b) {
-  return a < b ? [a, b] : [b, a];
+function isScoringSetKey(value) {
+  return SCORING_SET_KEYS.includes(value);
 }
-async function strengthenCoRecallEdges(db, usedEntryIds, timestamp2) {
-  const uniqueIds = Array.from(
-    new Set(
-      usedEntryIds.map((id) => id.trim()).filter((id) => id.length > 0)
-    )
-  ).slice(0, MAX_USED_ENTRIES);
-  if (uniqueIds.length < 2) {
-    return;
-  }
-  const now = timestamp2 || (/* @__PURE__ */ new Date()).toISOString();
-  const pairs = [];
-  for (let i = 0; i < uniqueIds.length; i += 1) {
-    const a = uniqueIds[i];
-    if (!a) {
-      continue;
-    }
-    for (let j = i + 1; j < uniqueIds.length; j += 1) {
-      const b = uniqueIds[j];
-      if (!b || a === b) {
-        continue;
-      }
-      pairs.push(normalizePair(a, b));
-    }
-  }
-  if (pairs.length === 0) {
-    return;
-  }
-  await db.execute("BEGIN");
-  try {
-    for (const [entryA, entryB] of pairs) {
-      await db.execute({
-        sql: `
-          INSERT INTO co_recall_edges (
-            entry_a, entry_b, edge_type, weight, session_count, last_co_recalled, created_at
-          )
-          VALUES (?, ?, ?, ?, 1, ?, ?)
-          ON CONFLICT
-          DO UPDATE SET
-            weight = MIN(co_recall_edges.weight + excluded.weight, 1.0),
-            session_count = co_recall_edges.session_count + 1,
-            last_co_recalled = excluded.last_co_recalled
-        `,
-        args: [
-          entryA,
-          entryB,
-          CO_RECALL_EDGE_TYPE,
-          DEFAULT_EDGE_INCREMENT,
-          now,
-          now
-        ]
-      });
-    }
-    await db.execute("COMMIT");
-  } catch (error) {
-    try {
-      await db.execute("ROLLBACK");
-    } catch {
-    }
-    throw error;
-  }
+function isAgenrAuthMethod(value) {
+  return AUTH_METHOD_SET.has(value);
 }
-async function getCoRecallNeighbors(db, entryId, minWeight = 0.1, limit = 10) {
-  const normalizedId = entryId.trim();
-  if (!normalizedId) {
-    return [];
-  }
-  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
-  const safeMinWeight = Number.isFinite(minWeight) ? Math.max(minWeight, 0) : 0.1;
-  const result = await db.execute({
-    sql: `
-      SELECT
-        CASE WHEN entry_a = ? THEN entry_b ELSE entry_a END AS neighbor_id,
-        weight,
-        session_count,
-        last_co_recalled
-      FROM co_recall_edges
-      WHERE edge_type = ?
-        AND (entry_a = ? OR entry_b = ?)
-        AND weight >= ?
-      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
-      LIMIT ?
-    `,
-    args: [normalizedId, CO_RECALL_EDGE_TYPE, normalizedId, normalizedId, safeMinWeight, safeLimit]
-  });
-  return result.rows.map((row) => ({
-    entryId: toStringValue(row.neighbor_id),
-    weight: toNumber2(row.weight),
-    sessionCount: toNumber2(row.session_count),
-    lastCoRecalled: toStringValue(row.last_co_recalled)
-  }));
+function resolveDefaultKnowledgeDbPath() {
+  return path3.join(os3.homedir(), ".agenr", "knowledge.db");
 }
-async function getCoRecallEdgeCounts(db) {
-  const result = await db.execute({
-    sql: `
-      SELECT entry_id, COUNT(*) AS edge_count
-      FROM (
-        SELECT entry_a AS entry_id
-        FROM co_recall_edges
-        WHERE edge_type = ?
-        UNION ALL
-        SELECT entry_b AS entry_id
-        FROM co_recall_edges
-        WHERE edge_type = ?
-      )
-      GROUP BY entry_id
-    `,
-    args: [CO_RECALL_EDGE_TYPE, CO_RECALL_EDGE_TYPE]
-  });
-  const counts = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
-    const entryId = toStringValue(row.entry_id).trim();
-    if (!entryId) {
-      continue;
-    }
-    counts.set(entryId, Math.max(0, toNumber2(row.edge_count)));
+var SCORING_SET_KEYS, AUTH_METHOD_DEFINITIONS, AUTH_METHOD_SET, MODEL_TASK_KEYS, DEFAULT_EMBEDDING_PROVIDER, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_FORGETTING_SCORE_THRESHOLD, DEFAULT_FORGETTING_MAX_AGE_DAYS, DEFAULT_SCORING_FTS_BOOST, DEFAULT_SCORING_VECTOR_EXPONENT, DEFAULT_SCORING_IMPORTANCE_FLOOR, DEFAULT_SCORING_FRESHNESS_HIGH_HOURS, DEFAULT_SCORING_FRESHNESS_MEDIUM_HOURS, DEFAULT_SCORING_FRESHNESS_LOW_HOURS, DEFAULT_SCORING_RECENCY_HALFLIFE_PERMANENT, DEFAULT_SCORING_RECENCY_HALFLIFE_TEMPORARY, DEFAULT_SCORING_FRESHNESS_MIN_IMPORTANCE, DEFAULT_SCORING_CONTRADICTION_PENALTY, DEFAULT_SCORING_QUALITY_MIN, DEFAULT_SCORING_QUALITY_MAX, DEFAULT_SCORING_IMPORTANCE_BLEND, DEFAULT_SCORING_RECALL_BLEND, DEFAULT_SCORING_TODO_HALFLIFE_DAYS, DEFAULT_SCORING_TODO_FLOOR_HIGH, DEFAULT_SCORING_TODO_FLOOR_LOW, DEFAULT_QUALITY_EVOLUTION_RECALL_SATURATION, DEFAULT_QUALITY_EVOLUTION_EDGE_SATURATION, DEFAULT_QUALITY_EVOLUTION_RECENCY_HALF_LIFE_DAYS, DEFAULT_QUALITY_EVOLUTION_NEUTRAL_FLOOR, DEFAULT_QUALITY_EVOLUTION_GRACE_MULTIPLIER, DEFAULT_QUALITY_EVOLUTION_DECAY_STEEPNESS, DEFAULT_QUALITY_EVOLUTION_EMA_ALPHA, DEFAULT_CONTRADICTION_ENABLED, DEFAULT_TASK_MODEL, DEFAULT_SURGEON_MODEL, DEFAULT_AUTO_SUPERSEDE_CONFIDENCE, DEFAULT_CONTRADICTION_BLOCKING_THRESHOLD, DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE, MAX_CLAIM_EXTRACTION_BATCH_SIZE, DEFAULT_CLAIM_EXTRACTION_CONCURRENCY, MAX_CLAIM_EXTRACTION_CONCURRENCY, DEFAULT_SURGEON_CONTEXT_LIMIT, DEFAULT_SURGEON_COST_CAP, DEFAULT_SURGEON_DAILY_COST_CAP, DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS, DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE, DEFAULT_SURGEON_RETIREMENT_MAX_ACTIONS_PER_RUN, DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS, DEFAULT_SURGEON_DEDUP_MAX_MERGES_PER_RUN, DEFAULT_SURGEON_CONTRADICTIONS_MAX_ACTIONS_PER_RUN;
+var init_schema2 = __esm({
+  "src/shared/infrastructure/config/schema.ts"() {
+    "use strict";
+    SCORING_SET_KEYS = [
+      "scoring.ftsBoost",
+      "scoring.vectorExponent",
+      "scoring.importanceFloor",
+      "scoring.freshnessWindow.high",
+      "scoring.freshnessWindow.medium",
+      "scoring.freshnessWindow.low",
+      "scoring.recencyHalfLife.permanent",
+      "scoring.recencyHalfLife.temporary",
+      "scoring.freshnessMinImportance",
+      "scoring.contradictionPenalty",
+      "scoring.qualityRange.min",
+      "scoring.qualityRange.max",
+      "scoring.importanceBlend.importance",
+      "scoring.importanceBlend.recall",
+      "scoring.todoPenalty.halfLifeDays",
+      "scoring.todoPenalty.floorHigh",
+      "scoring.todoPenalty.floorLow"
+    ];
+    AUTH_METHOD_DEFINITIONS = [
+      {
+        id: "anthropic-oauth",
+        provider: "anthropic",
+        title: "Anthropic - Claude subscription (OAuth)",
+        setupDescription: "Uses your Claude Pro/Team subscription via Claude CLI credentials. No per-token cost. Requires Claude Code CLI.",
+        preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
+      },
+      {
+        id: "anthropic-token",
+        provider: "anthropic",
+        title: "Anthropic - Claude subscription (long-lived token)",
+        setupDescription: "Uses a long-lived token from `claude setup-token`. No per-token cost. Simpler setup.",
+        preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
+      },
+      {
+        id: "anthropic-api-key",
+        provider: "anthropic",
+        title: "Anthropic - API key",
+        setupDescription: "Standard API key from console.anthropic.com. Pay per token.",
+        preferredModels: ["claude-sonnet-4-20250514", "claude-opus-4-6", "claude-haiku-3-5-20241022"]
+      },
+      {
+        id: "openai-subscription",
+        provider: "openai-codex",
+        title: "OpenAI - Subscription (via Codex CLI)",
+        setupDescription: "Uses your ChatGPT Plus subscription via Codex CLI credentials. No per-token cost. Requires Codex CLI.",
+        preferredModels: ["gpt-5.3-codex", "o3-codex"]
+      },
+      {
+        id: "openai-api-key",
+        provider: "openai",
+        title: "OpenAI - API key",
+        setupDescription: "Standard API key from https://platform.openai.com/api-keys. Pay per token.",
+        preferredModels: ["gpt-5.4-mini", "gpt-5.4", "gpt-4.1-mini"]
+      }
+    ];
+    AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((item) => item.id));
+    MODEL_TASK_KEYS = [
+      "extraction",
+      "claimExtraction",
+      "contradictionJudge",
+      "handoffSummary"
+    ];
+    DEFAULT_EMBEDDING_PROVIDER = "openai";
+    DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+    DEFAULT_EMBEDDING_DIMENSIONS = 1024;
+    DEFAULT_FORGETTING_SCORE_THRESHOLD = 0.05;
+    DEFAULT_FORGETTING_MAX_AGE_DAYS = 60;
+    DEFAULT_SCORING_FTS_BOOST = 1.3;
+    DEFAULT_SCORING_VECTOR_EXPONENT = 0.7;
+    DEFAULT_SCORING_IMPORTANCE_FLOOR = 0.55;
+    DEFAULT_SCORING_FRESHNESS_HIGH_HOURS = 1;
+    DEFAULT_SCORING_FRESHNESS_MEDIUM_HOURS = 6;
+    DEFAULT_SCORING_FRESHNESS_LOW_HOURS = 24;
+    DEFAULT_SCORING_RECENCY_HALFLIFE_PERMANENT = 365;
+    DEFAULT_SCORING_RECENCY_HALFLIFE_TEMPORARY = 30;
+    DEFAULT_SCORING_FRESHNESS_MIN_IMPORTANCE = 6;
+    DEFAULT_SCORING_CONTRADICTION_PENALTY = 0.8;
+    DEFAULT_SCORING_QUALITY_MIN = 0.7;
+    DEFAULT_SCORING_QUALITY_MAX = 1.3;
+    DEFAULT_SCORING_IMPORTANCE_BLEND = 0.7;
+    DEFAULT_SCORING_RECALL_BLEND = 0.3;
+    DEFAULT_SCORING_TODO_HALFLIFE_DAYS = 7;
+    DEFAULT_SCORING_TODO_FLOOR_HIGH = 0.4;
+    DEFAULT_SCORING_TODO_FLOOR_LOW = 0.1;
+    DEFAULT_QUALITY_EVOLUTION_RECALL_SATURATION = 10;
+    DEFAULT_QUALITY_EVOLUTION_EDGE_SATURATION = 8;
+    DEFAULT_QUALITY_EVOLUTION_RECENCY_HALF_LIFE_DAYS = 30;
+    DEFAULT_QUALITY_EVOLUTION_NEUTRAL_FLOOR = 0.35;
+    DEFAULT_QUALITY_EVOLUTION_GRACE_MULTIPLIER = 1;
+    DEFAULT_QUALITY_EVOLUTION_DECAY_STEEPNESS = 0.1;
+    DEFAULT_QUALITY_EVOLUTION_EMA_ALPHA = 0.3;
+    DEFAULT_CONTRADICTION_ENABLED = true;
+    DEFAULT_TASK_MODEL = "gpt-5.4-mini";
+    DEFAULT_SURGEON_MODEL = "gpt-5.4";
+    DEFAULT_AUTO_SUPERSEDE_CONFIDENCE = 0.85;
+    DEFAULT_CONTRADICTION_BLOCKING_THRESHOLD = 0.85;
+    DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE = 10;
+    MAX_CLAIM_EXTRACTION_BATCH_SIZE = 25;
+    DEFAULT_CLAIM_EXTRACTION_CONCURRENCY = 5;
+    MAX_CLAIM_EXTRACTION_CONCURRENCY = 50;
+    DEFAULT_SURGEON_CONTEXT_LIMIT = null;
+    DEFAULT_SURGEON_COST_CAP = 5;
+    DEFAULT_SURGEON_DAILY_COST_CAP = 15;
+    DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS = 14;
+    DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE = 8;
+    DEFAULT_SURGEON_RETIREMENT_MAX_ACTIONS_PER_RUN = 100;
+    DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS = 7;
+    DEFAULT_SURGEON_DEDUP_MAX_MERGES_PER_RUN = 100;
+    DEFAULT_SURGEON_CONTRADICTIONS_MAX_ACTIONS_PER_RUN = 100;
   }
-  return counts;
+});
+
+// src/shared/utils/source-classification.ts
+function normalizeSourceToken(sourceFile) {
+  return sourceFile?.trim().toLowerCase() ?? "";
 }
-async function getTopCoRecallEdges(db, limit = 20) {
-  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
-  const result = await db.execute({
-    sql: `
-      SELECT entry_a, entry_b, weight, session_count, last_co_recalled
-      FROM co_recall_edges
-      WHERE edge_type = ?
-      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
-      LIMIT ?
-    `,
-    args: [CO_RECALL_EDGE_TYPE, safeLimit]
-  });
-  return result.rows.map((row) => ({
-    entryA: toStringValue(row.entry_a),
-    entryB: toStringValue(row.entry_b),
-    weight: toNumber2(row.weight),
-    sessionCount: toNumber2(row.session_count),
-    lastCoRecalled: toStringValue(row.last_co_recalled)
-  }));
+function normalizeSourceClass(value) {
+  const normalized = value?.trim().toLowerCase() ?? "";
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "agent") {
+    return "tool";
+  }
+  return SOURCE_CLASS_SET.has(normalized) ? normalized : null;
 }
-var DEFAULT_EDGE_INCREMENT, MAX_USED_ENTRIES, CO_RECALL_EDGE_TYPE;
-var init_co_recall = __esm({
-  "src/shared/infrastructure/db/co-recall.ts"() {
+function isToolSourceFile(sourceFile) {
+  return normalizeSourceToken(sourceFile).startsWith(TOOL_SOURCE_PREFIX);
+}
+function classifyEntrySource(sourceFile) {
+  const normalized = normalizeSourceToken(sourceFile);
+  if (!normalized) {
+    return "system";
+  }
+  if (isToolSourceFile(normalized)) {
+    return "tool";
+  }
+  if (SYSTEM_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+    return "system";
+  }
+  if (IMPORT_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+    return "import";
+  }
+  if (CLI_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+    return "cli";
+  }
+  if (WATCHER_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix)) || normalized.includes("/") || normalized.includes("\\")) {
+    return "watcher";
+  }
+  return "system";
+}
+function sourceClassTrustLevel(sourceClass) {
+  return sourceClass === "tool" ? "high" : "low";
+}
+var TOOL_SOURCE_PREFIX, SOURCE_CLASSES, SOURCE_CLASS_SET, SYSTEM_SOURCE_PREFIXES, CLI_SOURCE_PREFIXES, WATCHER_SOURCE_PREFIXES, IMPORT_SOURCE_PREFIXES;
+var init_source_classification = __esm({
+  "src/shared/utils/source-classification.ts"() {
     "use strict";
-    init_entry_utils();
-    DEFAULT_EDGE_INCREMENT = 0.1;
-    MAX_USED_ENTRIES = 20;
-    CO_RECALL_EDGE_TYPE = "co_recalled";
+    TOOL_SOURCE_PREFIX = "stdin:tool";
+    SOURCE_CLASSES = [
+      "tool",
+      "watcher",
+      "cli",
+      "import",
+      "system"
+    ];
+    SOURCE_CLASS_SET = new Set(SOURCE_CLASSES);
+    SYSTEM_SOURCE_PREFIXES = [
+      "stdin:migration-",
+      "stdin:system-",
+      "migration:",
+      "system:",
+      "_meta:"
+    ];
+    CLI_SOURCE_PREFIXES = [
+      "stdin:",
+      "cli:"
+    ];
+    WATCHER_SOURCE_PREFIXES = [
+      "file:",
+      "session:",
+      "conversation"
+    ];
+    IMPORT_SOURCE_PREFIXES = [
+      "import:"
+    ];
+  }
+});
+
+// src/shared/domain/retirement-thresholds.ts
+function parseIsoTime(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function computeCorpusExposureAgeDays(input) {
+  const createdAtMs = parseIsoTime(input.createdAt);
+  if (createdAtMs === null) {
+    return null;
+  }
+  const rebuildAtMs = parseIsoTime(input.lastCorpusRebuildAt);
+  const exposureStartMs = rebuildAtMs === null ? createdAtMs : Math.max(createdAtMs, rebuildAtMs);
+  const ageDays = (input.now.getTime() - exposureStartMs) / DAY_MS;
+  return Number.isFinite(ageDays) ? Math.max(0, ageDays) : null;
+}
+var DAY_MS, DEFAULT_TEMPORARY_ENTRY_TTL_ENABLED, DEFAULT_TEMPORARY_ENTRY_TTL_DAYS, DEFAULT_TEMPORARY_ENTRY_TTL_MAX_IMPORTANCE, DEFAULT_TEMPORARY_ENTRY_TTL_REQUIRE_ZERO_RECALL;
+var init_retirement_thresholds = __esm({
+  "src/shared/domain/retirement-thresholds.ts"() {
+    "use strict";
+    init_source_classification();
+    DAY_MS = 24 * 60 * 60 * 1e3;
+    DEFAULT_TEMPORARY_ENTRY_TTL_ENABLED = true;
+    DEFAULT_TEMPORARY_ENTRY_TTL_DAYS = 21;
+    DEFAULT_TEMPORARY_ENTRY_TTL_MAX_IMPORTANCE = 6;
+    DEFAULT_TEMPORARY_ENTRY_TTL_REQUIRE_ZERO_RECALL = true;
+  }
+});
+
+// src/shared/domain/quality-tiers.ts
+function qualityTier(score) {
+  if (score >= QUALITY_TIER_HIGH) {
+    return "high";
+  }
+  if (score >= QUALITY_TIER_MEDIUM) {
+    return "medium";
+  }
+  return "low";
+}
+var QUALITY_TIER_HIGH, QUALITY_TIER_MEDIUM;
+var init_quality_tiers = __esm({
+  "src/shared/domain/quality-tiers.ts"() {
+    "use strict";
+    QUALITY_TIER_HIGH = 0.7;
+    QUALITY_TIER_MEDIUM = 0.4;
   }
 });
 
@@ -3134,18 +3654,39 @@ function qualityFloorByType(type) {
     return 0.35;
   }
   if (type === "decision" || type === "lesson") {
+    return 0.3;
+  }
+  if (type === "reflection") {
+    return 0.3;
+  }
+  if (type === "relationship") {
     return 0.25;
   }
-  if (type === "todo" || type === "event" || type === "relationship") {
-    return 0.15;
+  if (type === "todo" || type === "event") {
+    return 0.2;
   }
-  return 0.1;
+  return 0.2;
 }
-function computeDecayPenalty(daysSinceLastRecall) {
-  if (daysSinceLastRecall <= 60) {
-    return 1;
+function expectedRecallCycleDays(type) {
+  switch (type) {
+    case "preference":
+      return 14;
+    case "fact":
+      return 21;
+    case "decision":
+    case "lesson":
+      return 60;
+    case "event":
+      return 14;
+    case "todo":
+      return 7;
+    case "relationship":
+      return 30;
+    case "reflection":
+      return 90;
+    default:
+      return 30;
   }
-  return Math.max(0.3, 1 - (daysSinceLastRecall - 60) / 180);
 }
 function extractTextFromContent(content, separator) {
   if (typeof content === "string") {
@@ -3378,23 +3919,23 @@ async function evolveQualityScores(db, options = {}, config) {
     };
   }
   const qualityEvolutionConfig = config?.scoring?.qualityEvolution;
-  const recallSaturationRaw = qualityEvolutionConfig?.recallSaturation ?? 10;
-  const edgeSaturationRaw = qualityEvolutionConfig?.edgeSaturation ?? 8;
-  const recallSaturation = Number.isFinite(recallSaturationRaw) && recallSaturationRaw > 0 ? recallSaturationRaw : 10;
-  const edgeSaturation = Number.isFinite(edgeSaturationRaw) && edgeSaturationRaw > 0 ? edgeSaturationRaw : 8;
-  const recallWeight = Number.isFinite(qualityEvolutionConfig?.recallWeight) ? Number(qualityEvolutionConfig?.recallWeight) : 0.25;
-  const edgeWeight = Number.isFinite(qualityEvolutionConfig?.edgeWeight) ? Number(qualityEvolutionConfig?.edgeWeight) : 0.15;
-  const confirmWeight = Number.isFinite(qualityEvolutionConfig?.confirmWeight) ? Number(qualityEvolutionConfig?.confirmWeight) : 0.15;
-  const importanceWeight = Number.isFinite(qualityEvolutionConfig?.importanceWeight) ? Number(qualityEvolutionConfig?.importanceWeight) : 0.2;
-  const maxEvolveWeightRaw = qualityEvolutionConfig?.maxEvolveWeight ?? 0.6;
-  const minEvolveWeightRaw = qualityEvolutionConfig?.minEvolveWeight ?? 0.2;
-  const maxEvolveWeight = Number.isFinite(maxEvolveWeightRaw) ? clamp(maxEvolveWeightRaw, 0, 1) : 0.6;
-  const minEvolveWeightCandidate = Number.isFinite(minEvolveWeightRaw) ? minEvolveWeightRaw : 0.2;
-  const minEvolveWeight = clamp(minEvolveWeightCandidate, 0, maxEvolveWeight);
-  const neverRecalledDecayFloorRaw = qualityEvolutionConfig?.neverRecalledDecayFloor ?? 0.7;
-  const neverRecalledDecayFloor = Number.isFinite(neverRecalledDecayFloorRaw) ? clamp(neverRecalledDecayFloorRaw, 0, 1) : 0.7;
-  const edgeCounts = await getCoRecallEdgeCounts(db);
+  const recallSaturationRaw = qualityEvolutionConfig?.recallSaturation ?? DEFAULT_QUALITY_EVOLUTION_RECALL_SATURATION;
+  const edgeSaturationRaw = qualityEvolutionConfig?.edgeSaturation ?? DEFAULT_QUALITY_EVOLUTION_EDGE_SATURATION;
+  const recallSaturation = Number.isFinite(recallSaturationRaw) && recallSaturationRaw > 0 ? recallSaturationRaw : DEFAULT_QUALITY_EVOLUTION_RECALL_SATURATION;
+  const edgeSaturation = Number.isFinite(edgeSaturationRaw) && edgeSaturationRaw > 0 ? edgeSaturationRaw : DEFAULT_QUALITY_EVOLUTION_EDGE_SATURATION;
+  const recencyHalfLifeDaysRaw = qualityEvolutionConfig?.recencyHalfLifeDays ?? DEFAULT_QUALITY_EVOLUTION_RECENCY_HALF_LIFE_DAYS;
+  const recencyHalfLifeDays = Number.isFinite(recencyHalfLifeDaysRaw) && recencyHalfLifeDaysRaw > 0 ? recencyHalfLifeDaysRaw : DEFAULT_QUALITY_EVOLUTION_RECENCY_HALF_LIFE_DAYS;
+  const neutralFloorRaw = qualityEvolutionConfig?.neutralFloor ?? DEFAULT_QUALITY_EVOLUTION_NEUTRAL_FLOOR;
+  const neutralFloor = Number.isFinite(neutralFloorRaw) ? clamp(neutralFloorRaw, 0, 1) : DEFAULT_QUALITY_EVOLUTION_NEUTRAL_FLOOR;
+  const graceMultiplierRaw = qualityEvolutionConfig?.graceMultiplier ?? DEFAULT_QUALITY_EVOLUTION_GRACE_MULTIPLIER;
+  const graceMultiplier = Number.isFinite(graceMultiplierRaw) && graceMultiplierRaw > 0 ? graceMultiplierRaw : DEFAULT_QUALITY_EVOLUTION_GRACE_MULTIPLIER;
+  const decaySteepnessRaw = qualityEvolutionConfig?.decaySteepness ?? DEFAULT_QUALITY_EVOLUTION_DECAY_STEEPNESS;
+  const decaySteepness = Number.isFinite(decaySteepnessRaw) && decaySteepnessRaw >= 0 ? decaySteepnessRaw : DEFAULT_QUALITY_EVOLUTION_DECAY_STEEPNESS;
+  const emaAlphaRaw = qualityEvolutionConfig?.emaAlpha ?? DEFAULT_QUALITY_EVOLUTION_EMA_ALPHA;
+  const emaAlpha = Number.isFinite(emaAlphaRaw) ? clamp(emaAlphaRaw, 0, 1) : DEFAULT_QUALITY_EVOLUTION_EMA_ALPHA;
+  const edgeCounts = await getCoRecallEdgeCounts(db, CO_RECALL_EDGE_TYPE);
   const now = options.now ?? /* @__PURE__ */ new Date();
+  const lastCorpusRebuildAt = await getLastCorpusRebuildAt(db);
   let high = 0;
   let medium = 0;
   let low = 0;
@@ -3402,34 +3943,61 @@ async function evolveQualityScores(db, options = {}, config) {
   let totalAfter = 0;
   const updates = [];
   for (const row of rows) {
-    const recallSignal = row.recallCount > 0 ? clamp(Math.log1p(row.recallCount) / Math.log1p(recallSaturation), 0, 1) : 0;
     const edgeCount = edgeCounts.get(row.id) ?? 0;
-    const edgeSignal = edgeCount > 0 ? clamp(Math.log1p(edgeCount) / Math.log1p(edgeSaturation), 0, 1) : 0;
-    const confirmSignal = clamp(row.confirmations / 3, 0, 1);
-    const importanceNormalized = clamp(row.importance / 10, 0, 1);
-    const sourceDate = row.lastRecalledAt || row.createdAt;
-    const daysSinceLastRecall = parseDaysBetween(now, sourceDate || void 0);
-    const decayPenalty = row.recallCount > 0 ? computeDecayPenalty(daysSinceLastRecall) : Math.max(neverRecalledDecayFloor, computeDecayPenalty(daysSinceLastRecall));
-    const rawQuality = (recallWeight * recallSignal + edgeWeight * edgeSignal + confirmWeight * confirmSignal + importanceWeight * importanceNormalized) * decayPenalty;
-    const evolved = clamp(rawQuality, 0.05, 1);
     const existingQuality = clamp(Number.isFinite(row.qualityScore) ? row.qualityScore : 0.5, 0, 1);
-    const hasRecallData = row.recallCount > 0;
-    const hasEdgeData = edgeCount > 0;
-    const hasConfirmData = row.confirmations > 0;
-    const signalCount = (hasRecallData ? 1 : 0) + (hasEdgeData ? 1 : 0) + (hasConfirmData ? 1 : 0);
-    const evolveWeight = minEvolveWeight + signalCount / 3 * (maxEvolveWeight - minEvolveWeight);
-    const blendedQuality = evolveWeight * evolved + (1 - evolveWeight) * existingQuality;
-    const finalQuality = clamp(Math.max(blendedQuality, qualityFloorByType(row.type)), 0.05, 1);
-    totalBefore += existingQuality;
-    totalAfter += finalQuality;
-    if (finalQuality >= 0.7) {
-      high += 1;
-    } else if (finalQuality >= 0.3) {
-      medium += 1;
+    const effectiveObservationDays = computeCorpusExposureAgeDays({
+      createdAt: row.createdAt,
+      now,
+      lastCorpusRebuildAt
+    }) ?? 0;
+    const expectedCycleDays = expectedRecallCycleDays(row.type);
+    const graceWindowDays = expectedCycleDays * graceMultiplier;
+    const inGracePeriod = effectiveObservationDays < graceWindowDays;
+    const hasAnyPositiveSignal = row.recallCount > 0 || row.confirmations > 0 || edgeCount > 0;
+    let finalQuality = existingQuality;
+    if (inGracePeriod && !hasAnyPositiveSignal) {
+      finalQuality = existingQuality;
+    } else if (!hasAnyPositiveSignal) {
+      const importanceDampener = 1 + clamp(row.importance / 10, 0, 1) * 2;
+      const excessDays = Math.max(0, effectiveObservationDays - graceWindowDays);
+      const baselineQuality = Math.max(existingQuality, neutralFloor);
+      const decayRate = excessDays / (expectedCycleDays * importanceDampener);
+      const decayFactor = Math.exp(-decayRate * decaySteepness);
+      finalQuality = neutralFloor + (baselineQuality - neutralFloor) * decayFactor;
     } else {
-      low += 1;
-    }
-    updates.push({ id: row.id, qualityScore: finalQuality });
+      const recallSignal = row.recallCount > 0 ? clamp(Math.log1p(row.recallCount) / Math.log1p(recallSaturation), 0, 1) : 0;
+      const daysSinceLastRecall = row.lastRecalledAt ? parseDaysBetween(now, row.lastRecalledAt) : Number.POSITIVE_INFINITY;
+      const recencySignal = Number.isFinite(daysSinceLastRecall) ? Math.exp(-daysSinceLastRecall / recencyHalfLifeDays) : 0;
+      const confirmSignal = clamp(row.confirmations / 3, 0, 1);
+      const edgeSignal = edgeCount > 0 ? clamp(Math.log1p(edgeCount) / Math.log1p(edgeSaturation), 0, 1) : 0;
+      const rawEvidence = clamp(
+        EVIDENCE_WEIGHTS.recall * recallSignal + EVIDENCE_WEIGHTS.recency * recencySignal + EVIDENCE_WEIGHTS.confirm * confirmSignal + EVIDENCE_WEIGHTS.edge * edgeSignal,
+        0,
+        1
+      );
+      const evidenceQuality = clamp(
+        EVIDENCE_QUALITY_BASELINE + rawEvidence * EVIDENCE_QUALITY_RANGE,
+        EVIDENCE_QUALITY_BASELINE,
+        0.95
+      );
+      const blendedEvidence = emaAlpha * evidenceQuality + (1 - emaAlpha) * existingQuality;
+      finalQuality = Math.max(existingQuality, blendedEvidence);
+    }
+    finalQuality = clamp(Math.max(finalQuality, qualityFloorByType(row.type)), 0.1, 0.98);
+    totalBefore += existingQuality;
+    totalAfter += finalQuality;
+    switch (qualityTier(finalQuality)) {
+      case "high":
+        high += 1;
+        break;
+      case "medium":
+        medium += 1;
+        break;
+      default:
+        low += 1;
+        break;
+    }
+    updates.push({ id: row.id, qualityScore: finalQuality });
   }
   if (updates.length > 0) {
     await db.execute("BEGIN");
@@ -3565,12 +4133,16 @@ async function computeRecallFeedback(db, sessionKey, messages, recalledEntryIds,
     updatedIds: updates.map((update) => update.id)
   };
 }
-var RESPONSE_MIN_CHARS, RESPONSE_MAX_CHARS;
+var RESPONSE_MIN_CHARS, RESPONSE_MAX_CHARS, EVIDENCE_QUALITY_BASELINE, EVIDENCE_QUALITY_RANGE, EVIDENCE_WEIGHTS;
 var init_feedback = __esm({
   "src/shared/infrastructure/db/feedback.ts"() {
     "use strict";
     init_client2();
+    init_schema2();
+    init_retirement_thresholds();
+    init_quality_tiers();
     init_co_recall();
+    init_meta();
     init_metrics();
     init_entry_utils();
     init_errors();
@@ -3578,6 +4150,14 @@ var init_feedback = __esm({
     init_vector();
     RESPONSE_MIN_CHARS = 50;
     RESPONSE_MAX_CHARS = 8e3;
+    EVIDENCE_QUALITY_BASELINE = 0.45;
+    EVIDENCE_QUALITY_RANGE = 0.5;
+    EVIDENCE_WEIGHTS = {
+      recall: 0.35,
+      recency: 0.25,
+      confirm: 0.2,
+      edge: 0.2
+    };
   }
 });
 
@@ -3867,144 +4447,6 @@ var init_stream = __esm({
   }
 });
 
-// src/shared/infrastructure/config/schema.ts
-import os3 from "os";
-import path3 from "path";
-function resolveClaimExtractionBatchSize(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    return DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE;
-  }
-  return Math.min(Math.floor(value), MAX_CLAIM_EXTRACTION_BATCH_SIZE);
-}
-function resolveClaimExtractionConcurrency(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    return DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
-  }
-  return Math.min(Math.floor(value), MAX_CLAIM_EXTRACTION_CONCURRENCY);
-}
-function isModelTask(value) {
-  return MODEL_TASK_KEYS.includes(value);
-}
-function isScoringSetKey(value) {
-  return SCORING_SET_KEYS.includes(value);
-}
-function isAgenrAuthMethod(value) {
-  return AUTH_METHOD_SET.has(value);
-}
-function resolveDefaultKnowledgeDbPath() {
-  return path3.join(os3.homedir(), ".agenr", "knowledge.db");
-}
-var SCORING_SET_KEYS, AUTH_METHOD_DEFINITIONS, AUTH_METHOD_SET, MODEL_TASK_KEYS, DEFAULT_EMBEDDING_PROVIDER, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_FORGETTING_SCORE_THRESHOLD, DEFAULT_FORGETTING_MAX_AGE_DAYS, DEFAULT_FORGETTING_LOW_SCORE_TRIGGER_COUNT, DEFAULT_SCORING_FTS_BOOST, DEFAULT_SCORING_VECTOR_EXPONENT, DEFAULT_SCORING_IMPORTANCE_FLOOR, DEFAULT_SCORING_FRESHNESS_HIGH_HOURS, DEFAULT_SCORING_FRESHNESS_MEDIUM_HOURS, DEFAULT_SCORING_FRESHNESS_LOW_HOURS, DEFAULT_SCORING_RECENCY_HALFLIFE_PERMANENT, DEFAULT_SCORING_RECENCY_HALFLIFE_TEMPORARY, DEFAULT_SCORING_FRESHNESS_MIN_IMPORTANCE, DEFAULT_SCORING_CONTRADICTION_PENALTY, DEFAULT_SCORING_QUALITY_MIN, DEFAULT_SCORING_QUALITY_MAX, DEFAULT_SCORING_IMPORTANCE_BLEND, DEFAULT_SCORING_RECALL_BLEND, DEFAULT_SCORING_TODO_HALFLIFE_DAYS, DEFAULT_SCORING_TODO_FLOOR_HIGH, DEFAULT_SCORING_TODO_FLOOR_LOW, DEFAULT_CONTRADICTION_ENABLED, DEFAULT_TASK_MODEL, DEFAULT_SURGEON_MODEL, DEFAULT_AUTO_SUPERSEDE_CONFIDENCE, DEFAULT_CONTRADICTION_BLOCKING_THRESHOLD, DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE, MAX_CLAIM_EXTRACTION_BATCH_SIZE, DEFAULT_CLAIM_EXTRACTION_CONCURRENCY, MAX_CLAIM_EXTRACTION_CONCURRENCY, DEFAULT_SURGEON_BUDGET, DEFAULT_SURGEON_COST_CAP, DEFAULT_SURGEON_DAILY_COST_CAP, DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS, DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE, DEFAULT_SURGEON_RETIREMENT_MAX_ACTIONS_PER_RUN, DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS, DEFAULT_SURGEON_DEDUP_MAX_MERGES_PER_RUN, DEFAULT_SURGEON_CONTRADICTIONS_MAX_ACTIONS_PER_RUN;
-var init_schema2 = __esm({
-  "src/shared/infrastructure/config/schema.ts"() {
-    "use strict";
-    SCORING_SET_KEYS = [
-      "scoring.ftsBoost",
-      "scoring.vectorExponent",
-      "scoring.importanceFloor",
-      "scoring.freshnessWindow.high",
-      "scoring.freshnessWindow.medium",
-      "scoring.freshnessWindow.low",
-      "scoring.recencyHalfLife.permanent",
-      "scoring.recencyHalfLife.temporary",
-      "scoring.freshnessMinImportance",
-      "scoring.contradictionPenalty",
-      "scoring.qualityRange.min",
-      "scoring.qualityRange.max",
-      "scoring.importanceBlend.importance",
-      "scoring.importanceBlend.recall",
-      "scoring.todoPenalty.halfLifeDays",
-      "scoring.todoPenalty.floorHigh",
-      "scoring.todoPenalty.floorLow"
-    ];
-    AUTH_METHOD_DEFINITIONS = [
-      {
-        id: "anthropic-oauth",
-        provider: "anthropic",
-        title: "Anthropic - Claude subscription (OAuth)",
-        setupDescription: "Uses your Claude Pro/Team subscription via Claude CLI credentials. No per-token cost. Requires Claude Code CLI.",
-        preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
-      },
-      {
-        id: "anthropic-token",
-        provider: "anthropic",
-        title: "Anthropic - Claude subscription (long-lived token)",
-        setupDescription: "Uses a long-lived token from `claude setup-token`. No per-token cost. Simpler setup.",
-        preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
-      },
-      {
-        id: "anthropic-api-key",
-        provider: "anthropic",
-        title: "Anthropic - API key",
-        setupDescription: "Standard API key from console.anthropic.com. Pay per token.",
-        preferredModels: ["claude-sonnet-4-20250514", "claude-opus-4-6", "claude-haiku-3-5-20241022"]
-      },
-      {
-        id: "openai-subscription",
-        provider: "openai-codex",
-        title: "OpenAI - Subscription (via Codex CLI)",
-        setupDescription: "Uses your ChatGPT Plus subscription via Codex CLI credentials. No per-token cost. Requires Codex CLI.",
-        preferredModels: ["gpt-5.3-codex", "o3-codex"]
-      },
-      {
-        id: "openai-api-key",
-        provider: "openai",
-        title: "OpenAI - API key",
-        setupDescription: "Standard API key from https://platform.openai.com/api-keys. Pay per token.",
-        preferredModels: ["gpt-5.4-mini", "gpt-5.4", "gpt-4.1-mini"]
-      }
-    ];
-    AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((item) => item.id));
-    MODEL_TASK_KEYS = [
-      "extraction",
-      "claimExtraction",
-      "contradictionJudge",
-      "handoffSummary"
-    ];
-    DEFAULT_EMBEDDING_PROVIDER = "openai";
-    DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
-    DEFAULT_EMBEDDING_DIMENSIONS = 1024;
-    DEFAULT_FORGETTING_SCORE_THRESHOLD = 0.05;
-    DEFAULT_FORGETTING_MAX_AGE_DAYS = 60;
-    DEFAULT_FORGETTING_LOW_SCORE_TRIGGER_COUNT = 200;
-    DEFAULT_SCORING_FTS_BOOST = 1.3;
-    DEFAULT_SCORING_VECTOR_EXPONENT = 0.7;
-    DEFAULT_SCORING_IMPORTANCE_FLOOR = 0.55;
-    DEFAULT_SCORING_FRESHNESS_HIGH_HOURS = 1;
-    DEFAULT_SCORING_FRESHNESS_MEDIUM_HOURS = 6;
-    DEFAULT_SCORING_FRESHNESS_LOW_HOURS = 24;
-    DEFAULT_SCORING_RECENCY_HALFLIFE_PERMANENT = 365;
-    DEFAULT_SCORING_RECENCY_HALFLIFE_TEMPORARY = 30;
-    DEFAULT_SCORING_FRESHNESS_MIN_IMPORTANCE = 6;
-    DEFAULT_SCORING_CONTRADICTION_PENALTY = 0.8;
-    DEFAULT_SCORING_QUALITY_MIN = 0.7;
-    DEFAULT_SCORING_QUALITY_MAX = 1.3;
-    DEFAULT_SCORING_IMPORTANCE_BLEND = 0.7;
-    DEFAULT_SCORING_RECALL_BLEND = 0.3;
-    DEFAULT_SCORING_TODO_HALFLIFE_DAYS = 7;
-    DEFAULT_SCORING_TODO_FLOOR_HIGH = 0.4;
-    DEFAULT_SCORING_TODO_FLOOR_LOW = 0.1;
-    DEFAULT_CONTRADICTION_ENABLED = true;
-    DEFAULT_TASK_MODEL = "gpt-5.4-mini";
-    DEFAULT_SURGEON_MODEL = "gpt-5.4";
-    DEFAULT_AUTO_SUPERSEDE_CONFIDENCE = 0.85;
-    DEFAULT_CONTRADICTION_BLOCKING_THRESHOLD = 0.85;
-    DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE = 10;
-    MAX_CLAIM_EXTRACTION_BATCH_SIZE = 25;
-    DEFAULT_CLAIM_EXTRACTION_CONCURRENCY = 5;
-    MAX_CLAIM_EXTRACTION_CONCURRENCY = 50;
-    DEFAULT_SURGEON_BUDGET = 2e5;
-    DEFAULT_SURGEON_COST_CAP = 5;
-    DEFAULT_SURGEON_DAILY_COST_CAP = 15;
-    DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS = 14;
-    DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE = 8;
-    DEFAULT_SURGEON_RETIREMENT_MAX_ACTIONS_PER_RUN = 100;
-    DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS = 7;
-    DEFAULT_SURGEON_DEDUP_MAX_MERGES_PER_RUN = 100;
-    DEFAULT_SURGEON_CONTRADICTIONS_MAX_ACTIONS_PER_RUN = 100;
-  }
-});
-
 // src/shared/infrastructure/llm/models.ts
 import { getModel } from "@mariozechner/pi-ai";
 function isAgenrProvider(value) {
@@ -4489,8 +4931,7 @@ function normalizeForgettingConfig(input) {
     protect: [],
     scoreThreshold: DEFAULT_FORGETTING_SCORE_THRESHOLD,
     maxAgeDays: DEFAULT_FORGETTING_MAX_AGE_DAYS,
-    enabled: true,
-    lowScoreTriggerCount: DEFAULT_FORGETTING_LOW_SCORE_TRIGGER_COUNT
+    enabled: true
   };
   if (!input || typeof input !== "object") {
     return normalized;
@@ -4508,8 +4949,33 @@ function normalizeForgettingConfig(input) {
   if (typeof record.enabled === "boolean") {
     normalized.enabled = record.enabled;
   }
-  if (typeof record.lowScoreTriggerCount === "number" && Number.isFinite(record.lowScoreTriggerCount) && record.lowScoreTriggerCount > 0) {
-    normalized.lowScoreTriggerCount = Math.floor(record.lowScoreTriggerCount);
+  if (typeof record.qualityPenaltyWeight === "number" && Number.isFinite(record.qualityPenaltyWeight) && record.qualityPenaltyWeight >= 0) {
+    normalized.qualityPenaltyWeight = record.qualityPenaltyWeight;
+  }
+  return normalized;
+}
+function normalizeTtlConfig(input) {
+  const normalized = {
+    enabled: DEFAULT_TEMPORARY_ENTRY_TTL_ENABLED,
+    temporaryMaxDays: DEFAULT_TEMPORARY_ENTRY_TTL_DAYS,
+    temporaryMaxImportance: DEFAULT_TEMPORARY_ENTRY_TTL_MAX_IMPORTANCE,
+    requireZeroRecall: DEFAULT_TEMPORARY_ENTRY_TTL_REQUIRE_ZERO_RECALL
+  };
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return normalized;
+  }
+  const record = input;
+  if (typeof record.enabled === "boolean") {
+    normalized.enabled = record.enabled;
+  }
+  if (typeof record.temporaryMaxDays === "number" && Number.isFinite(record.temporaryMaxDays) && record.temporaryMaxDays > 0) {
+    normalized.temporaryMaxDays = Math.floor(record.temporaryMaxDays);
+  }
+  if (typeof record.temporaryMaxImportance === "number" && Number.isFinite(record.temporaryMaxImportance) && record.temporaryMaxImportance >= 1 && record.temporaryMaxImportance <= 10) {
+    normalized.temporaryMaxImportance = Math.floor(record.temporaryMaxImportance);
+  }
+  if (typeof record.requireZeroRecall === "boolean") {
+    normalized.requireZeroRecall = record.requireZeroRecall;
   }
   return normalized;
 }
@@ -4650,7 +5116,7 @@ function normalizeContradictionConfig(input) {
 }
 function normalizeSurgeonConfig(input) {
   const normalized = {
-    budget: DEFAULT_SURGEON_BUDGET,
+    contextLimit: DEFAULT_SURGEON_CONTEXT_LIMIT,
     costCap: DEFAULT_SURGEON_COST_CAP,
     dailyCostCap: DEFAULT_SURGEON_DAILY_COST_CAP,
     passes: {
@@ -4676,8 +5142,12 @@ function normalizeSurgeonConfig(input) {
   if (typeof record.model === "string" && record.model.trim()) {
     normalized.model = record.model.trim();
   }
-  if (typeof record.budget === "number" && Number.isFinite(record.budget) && record.budget > 0) {
-    normalized.budget = Math.floor(record.budget);
+  if (typeof record.contextLimit === "number" && Number.isFinite(record.contextLimit) && record.contextLimit > 0) {
+    normalized.contextLimit = Math.floor(record.contextLimit);
+  } else if (record.contextLimit === null) {
+    normalized.contextLimit = null;
+  } else if (typeof record.budget === "number" && Number.isFinite(record.budget) && record.budget > 0) {
+    normalized.contextLimit = Math.floor(record.budget);
   }
   if (typeof record.costCap === "number" && Number.isFinite(record.costCap) && record.costCap > 0) {
     normalized.costCap = record.costCap;
@@ -4845,6 +5315,7 @@ function normalizeConfig(input) {
     embedding: normalizeEmbeddingConfig(record.embedding),
     db: normalizeDbConfig(record.db),
     forgetting: normalizeForgettingConfig(record.forgetting),
+    ttl: normalizeTtlConfig(record.ttl),
     scoring: normalizeScoringConfig(record.scoring),
     contradiction: normalizeContradictionConfig(record.contradiction),
     surgeon: normalizeSurgeonConfig(record.surgeon)
@@ -4890,6 +5361,7 @@ function normalizeConfig(input) {
 var init_normalize = __esm({
   "src/shared/infrastructure/config/normalize.ts"() {
     "use strict";
+    init_retirement_thresholds();
     init_fs();
     init_string();
     init_models();
@@ -4932,6 +5404,12 @@ function mergeConfigPatch(current, patch) {
       ...patch.forgetting ?? {}
     };
   }
+  if (current?.ttl || patch.ttl) {
+    merged.ttl = {
+      ...current?.ttl ?? {},
+      ...patch.ttl ?? {}
+    };
+  }
   if (current?.scoring || patch.scoring) {
     merged.scoring = {
       ...current?.scoring ?? {},
@@ -5407,6 +5885,7 @@ __export(config_exports, {
   AUTH_METHOD_DEFINITIONS: () => AUTH_METHOD_DEFINITIONS,
   DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE: () => DEFAULT_CLAIM_EXTRACTION_BATCH_SIZE,
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY: () => DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
+  DEFAULT_SURGEON_CONTEXT_LIMIT: () => DEFAULT_SURGEON_CONTEXT_LIMIT,
   DEFAULT_SURGEON_MODEL: () => DEFAULT_SURGEON_MODEL,
   DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS: () => DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS,
   DEFAULT_TASK_MODEL: () => DEFAULT_TASK_MODEL,
@@ -5888,83 +6367,6 @@ var init_openclaw = __esm({
   }
 });
 
-// src/shared/utils/source-classification.ts
-function normalizeSourceToken(sourceFile) {
-  return sourceFile?.trim().toLowerCase() ?? "";
-}
-function normalizeSourceClass(value) {
-  const normalized = value?.trim().toLowerCase() ?? "";
-  if (!normalized) {
-    return null;
-  }
-  if (normalized === "agent") {
-    return "tool";
-  }
-  return SOURCE_CLASS_SET.has(normalized) ? normalized : null;
-}
-function isToolSourceFile(sourceFile) {
-  return normalizeSourceToken(sourceFile).startsWith(TOOL_SOURCE_PREFIX);
-}
-function classifyEntrySource(sourceFile) {
-  const normalized = normalizeSourceToken(sourceFile);
-  if (!normalized) {
-    return "system";
-  }
-  if (isToolSourceFile(normalized)) {
-    return "tool";
-  }
-  if (SYSTEM_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-    return "system";
-  }
-  if (IMPORT_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-    return "import";
-  }
-  if (CLI_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-    return "cli";
-  }
-  if (WATCHER_SOURCE_PREFIXES.some((prefix) => normalized.startsWith(prefix)) || normalized.includes("/") || normalized.includes("\\")) {
-    return "watcher";
-  }
-  return "system";
-}
-function sourceClassTrustLevel(sourceClass) {
-  return sourceClass === "tool" ? "high" : "low";
-}
-var TOOL_SOURCE_PREFIX, SOURCE_CLASSES, SOURCE_CLASS_SET, SYSTEM_SOURCE_PREFIXES, CLI_SOURCE_PREFIXES, WATCHER_SOURCE_PREFIXES, IMPORT_SOURCE_PREFIXES;
-var init_source_classification = __esm({
-  "src/shared/utils/source-classification.ts"() {
-    "use strict";
-    TOOL_SOURCE_PREFIX = "stdin:tool";
-    SOURCE_CLASSES = [
-      "tool",
-      "watcher",
-      "cli",
-      "import",
-      "system"
-    ];
-    SOURCE_CLASS_SET = new Set(SOURCE_CLASSES);
-    SYSTEM_SOURCE_PREFIXES = [
-      "stdin:migration-",
-      "stdin:system-",
-      "migration:",
-      "system:",
-      "_meta:"
-    ];
-    CLI_SOURCE_PREFIXES = [
-      "stdin:",
-      "cli:"
-    ];
-    WATCHER_SOURCE_PREFIXES = [
-      "file:",
-      "session:",
-      "conversation"
-    ];
-    IMPORT_SOURCE_PREFIXES = [
-      "import:"
-    ];
-  }
-});
-
 // src/shared/infrastructure/db/stored-entry.ts
 function mapRawStoredEntry(row, options) {
   const canonicalKey = toStringValue(row.canonical_key).trim();
@@ -6207,9 +6609,9 @@ async function updateRecallMetadata(db, ids, now, options) {
   const previous = recallMetadataQueue.get(db) ?? Promise.resolve();
   const current = previous.catch(() => void 0).then(async () => {
     const nowIso = now.toISOString();
-    const sessionId = options?.sessionId ?? null;
-    const platform = options?.platform ?? null;
-    const project = options?.project ?? null;
+    const sessionId = options?.sessionId?.trim() || null;
+    const platform = options?.platform?.trim() || null;
+    const project = options?.project?.trim() || null;
     const runUpdates = async () => {
       for (const id of ids) {
         const entryRow = await db.execute({
@@ -6963,7 +7365,7 @@ var init_entry_utils2 = __esm({
 
 // src/modules/recall/domain/types.ts
 var DEFAULT_VECTOR_CANDIDATE_LIMIT, DEFAULT_LEXICAL_CANDIDATE_LIMIT, DEFAULT_LIMIT, DEFAULT_AROUND_RADIUS_DAYS, DEFAULT_RERANK_WINDOW;
-var init_types = __esm({
+var init_types2 = __esm({
   "src/modules/recall/domain/types.ts"() {
     "use strict";
     DEFAULT_VECTOR_CANDIDATE_LIMIT = 50;
@@ -7132,7 +7534,7 @@ var init_score = __esm({
     init_project2();
     init_source_classification2();
     init_entry_utils2();
-    init_types();
+    init_types2();
     IMPORTANCE_FLOOR = 0.55;
     RECENCY_HALFLIFE_PERMANENT_DAYS = 365;
     RECENCY_HALFLIFE_TEMPORARY_DAYS = 30;
@@ -7968,7 +8370,7 @@ var init_preparation = __esm({
     init_query_normalization();
     init_scope();
     init_score();
-    init_types();
+    init_types2();
   }
 });
 
@@ -8355,7 +8757,7 @@ var init_rerank = __esm({
     init_lexical();
     init_rerank_intent();
     init_text();
-    init_types();
+    init_types2();
     QUERY_PHRASE_WINDOW = 3;
   }
 });
@@ -8459,7 +8861,7 @@ async function finalizeRecallResults(params) {
 var init_finalize = __esm({
   "src/modules/recall/adapters/pipeline/finalize.ts"() {
     "use strict";
-    init_types();
+    init_types2();
   }
 });
 
@@ -9125,7 +9527,7 @@ var init_retrieval = __esm({
     init_candidate_scoring();
     init_entry_filters();
     init_lexical();
-    init_types();
+    init_types2();
     init_session_start();
     init_candidates();
     init_helpers();
@@ -9197,7 +9599,7 @@ var init_outbound = __esm({
     init_retrieval();
     init_helpers();
     init_score();
-    init_types();
+    init_types2();
     init_score();
     init_score();
     init_session_start();
@@ -9328,7 +9730,7 @@ var init_recall = __esm({
     init_rerank();
     init_trace();
     init_outbound();
-    init_types();
+    init_types2();
   }
 });
 
@@ -12644,30 +13046,6 @@ var init_jsonl_generic = __esm({
   }
 });
 
-// src/shared/domain/types.ts
-var KNOWLEDGE_TYPES, IMPORTANCE_MIN, IMPORTANCE_MAX, EXPIRY_LEVELS, SCOPE_LEVELS, KNOWLEDGE_PLATFORMS, REJECTED_CONFLICT_ENTRY_ID;
-var init_types2 = __esm({
-  "src/shared/domain/types.ts"() {
-    "use strict";
-    KNOWLEDGE_TYPES = [
-      "fact",
-      "decision",
-      "preference",
-      "todo",
-      "relationship",
-      "event",
-      "lesson",
-      "reflection"
-    ];
-    IMPORTANCE_MIN = 1;
-    IMPORTANCE_MAX = 10;
-    EXPIRY_LEVELS = ["core", "permanent", "temporary"];
-    SCOPE_LEVELS = ["private", "personal", "public"];
-    KNOWLEDGE_PLATFORMS = ["openclaw", "claude-code", "codex", "plaud"];
-    REJECTED_CONFLICT_ENTRY_ID = "rejected";
-  }
-});
-
 // src/shared/utils/expiry.ts
 function normalizeExpiry(value) {
   if (typeof value !== "string") {
@@ -12686,7 +13064,7 @@ var EXPIRY_SET, EXPIRY_PRIORITY;
 var init_expiry = __esm({
   "src/shared/utils/expiry.ts"() {
     "use strict";
-    init_types2();
+    init_types();
     EXPIRY_SET = new Set(EXPIRY_LEVELS);
     EXPIRY_PRIORITY = {
       temporary: 0,
@@ -15138,7 +15516,7 @@ var MIN_CONTENT_LENGTH, MAX_CONTENT_LENGTH, MAX_SUBJECT_LENGTH, MIN_IMPORTANCE_F
 var init_entry_validator = __esm({
   "src/modules/ingestion/domain/validation/entry-validator.ts"() {
     "use strict";
-    init_types2();
+    init_types();
     init_content_patterns();
     init_extraction_guards();
     MIN_CONTENT_LENGTH = 20;
@@ -18778,7 +19156,7 @@ var init_write_queue = __esm({
 var init_types3 = __esm({
   "src/types.ts"() {
     "use strict";
-    init_types2();
+    init_types();
   }
 });
 
@@ -23749,6 +24127,7 @@ var init_ingestion = __esm({
     init_lockfile();
     init_minhash();
     init_schema();
+    init_meta();
     init_queries();
     init_cache();
     init_client2();
@@ -24272,6 +24651,7 @@ function resolveDbCommandDefaults() {
     initDb: shared.initDbFn,
     closeDb: shared.closeDbFn,
     backupDb,
+    checkVectorIntegrity,
     getConflictShadowSummary,
     resetDb,
     walCheckpoint,
@@ -26154,1170 +26534,1186 @@ function formatPerfLog(fields) {
 init_inbound();
 init_project();
 
-// src/edge/openclaw/memory-index.ts
-init_inbound();
+// src/edge/openclaw/session-state.ts
 init_errors();
-var MEMORY_INDEX_TIMEOUT_MS = 1e4;
-var MEMORY_INDEX_TIMEOUT = /* @__PURE__ */ Symbol("memory-index-timeout");
-function normalizeDate(value) {
-  const raw = typeof value === "string" ? value.trim() : "";
-  if (!raw) {
-    return "";
+init_logger();
+
+// src/edge/openclaw/surfaced-memory-ledger.ts
+var MAX_RECALLED_SESSIONS = 200;
+var SESSION_SURFACED_MEMORY_INTENTS = {
+  startupPromptVisibleRecall: {
+    writeProfile: {
+      surface: "session-start",
+      source: "startup-prompt-visible",
+      ownership: "before-reset-owned"
+    },
+    read: {
+      sharedSelectors: ["dedupe-relevant", "before-reset-owned"]
+    },
+    lifecycle: {
+      ownership: "before-reset-owned",
+      commandReset: "preserve",
+      beforeResetFeedback: "owned"
+    }
+  },
+  midSessionPluginInjection: {
+    writeProfile: {
+      surface: "mid-session-recall",
+      source: "plugin-injection",
+      ownership: "dedupe-only"
+    },
+    read: {
+      sharedSelectors: ["dedupe-relevant"]
+    },
+    lifecycle: {
+      ownership: "dedupe-only",
+      commandReset: "clear",
+      beforeResetFeedback: "excluded"
+    }
+  },
+  agentToolRecallOutput: {
+    writeProfile: {
+      surface: "agent-tool-recall",
+      source: "agent-tool-output",
+      ownership: "dedupe-only"
+    },
+    read: {
+      sharedSelectors: ["dedupe-relevant"]
+    },
+    lifecycle: {
+      ownership: "dedupe-only",
+      commandReset: "clear",
+      beforeResetFeedback: "excluded"
+    }
   }
-  const parsed = new Date(raw);
-  if (Number.isNaN(parsed.getTime())) {
-    return raw;
+};
+function buildSessionSurfacedMemoryRecordProfiles() {
+  const profiles = {};
+  for (const [intent, definition] of Object.entries(SESSION_SURFACED_MEMORY_INTENTS)) {
+    profiles[intent] = definition.writeProfile;
   }
-  return parsed.toISOString();
+  return profiles;
 }
-function toProjectName(value) {
-  if (value === null || value === void 0) {
-    return null;
+var SESSION_SURFACED_MEMORY_RECORD_PROFILES = buildSessionSurfacedMemoryRecordProfiles();
+var SESSION_SURFACED_MEMORY_SELECTOR_FILTERS = {
+  "dedupe-relevant": {},
+  "before-reset-owned": { ownership: "before-reset-owned" }
+};
+var SESSION_SURFACED_MEMORY_SELECTORS = {
+  dedupeRelevant: "dedupe-relevant",
+  beforeResetOwned: "before-reset-owned",
+  intent(intent) {
+    return { kind: "intent", intent };
+  },
+  profile(profile) {
+    return { kind: "profile", profile };
+  },
+  source(source) {
+    return { kind: "source", source };
   }
-  const normalized = String(value).trim();
-  return normalized.length > 0 ? normalized : null;
+};
+function normalizeSessionKey(value) {
+  return value.trim();
 }
-function toCount(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return 0;
+function trimSurfacedMemoryLedgers(store) {
+  while (store.ledgers.size > MAX_RECALLED_SESSIONS) {
+    const oldestKey = store.ledgers.keys().next().value;
+    if (oldestKey === void 0) {
+      break;
+    }
+    store.ledgers.delete(oldestKey);
+    for (const [alias, canonicalKey] of store.aliases) {
+      if (canonicalKey === oldestKey) {
+        store.aliases.delete(alias);
+      }
+    }
   }
-  return Math.floor(parsed);
 }
-function normalizeProjectIndexEntry(value) {
-  if (!value || typeof value !== "object") {
-    return null;
+function touchSurfacedMemoryLedger(store, canonicalKey) {
+  const existing = store.ledgers.get(canonicalKey);
+  if (!existing) {
+    return;
   }
-  const row = value;
-  return {
-    project: toProjectName(row.project),
-    count: toCount(row.count),
-    lastUpdated: normalizeDate(row.lastUpdated ?? row.last_updated)
-  };
+  store.ledgers.delete(canonicalKey);
+  store.ledgers.set(canonicalKey, existing);
 }
-function parseMemoryIndex(value) {
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  const response = value;
-  if (!Array.isArray(response.projects)) {
-    return null;
+function resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey) {
+  const normalizedKey = normalizeSessionKey(sessionKey);
+  if (!normalizedKey) {
+    return "";
   }
-  const projects = response.projects.map((entry) => normalizeProjectIndexEntry(entry)).filter((entry) => entry !== null);
-  const totalFromResponse = Number(response.totalEntries);
-  const totalEntries = Number.isFinite(totalFromResponse) && totalFromResponse >= 0 ? Math.floor(totalFromResponse) : projects.reduce((sum, project) => sum + project.count, 0);
-  return { projects, totalEntries };
+  return store.aliases.get(normalizedKey) ?? normalizedKey;
 }
-async function runMemoryIndex(dbPath, executionOptions) {
-  try {
-    const timeoutMs = executionOptions?.timeoutMs ?? MEMORY_INDEX_TIMEOUT_MS;
-    const result = await withTimeout(
-      loadMemoryIndex(dbPath, executionOptions?.recallServiceDeps),
-      timeoutMs
-    );
-    if (result === MEMORY_INDEX_TIMEOUT) {
-      return { status: "timeout" };
-    }
-    return result;
-  } catch (error) {
-    return {
-      status: "error",
-      error: toErrorMessage(error)
-    };
+function getOrCreateSurfacedMemoryLedger(store, sessionKey) {
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
+  if (!canonicalKey) {
+    return null;
   }
-}
-async function loadMemoryIndex(dbPath, recallServiceDeps) {
-  const index = parseMemoryIndex(
-    await buildRecallIndex(
-      { dbPath },
-      { runtime: adaptLegacyRecallRuntimeDeps(recallServiceDeps) }
-    )
-  );
-  if (!index) {
-    return { status: "invalid" };
+  const existing = store.ledgers.get(canonicalKey);
+  if (existing) {
+    touchSurfacedMemoryLedger(store, canonicalKey);
+    return existing;
   }
-  return {
-    status: "ok",
-    index
+  const ledger = {
+    nextSequence: 1,
+    records: []
   };
+  store.ledgers.set(canonicalKey, ledger);
+  trimSurfacedMemoryLedgers(store);
+  return ledger;
 }
-async function withTimeout(promise, timeoutMs) {
-  let timer;
-  try {
-    return await new Promise((resolve, reject) => {
-      timer = setTimeout(() => {
-        resolve(MEMORY_INDEX_TIMEOUT);
-      }, timeoutMs);
-      promise.then(resolve).catch(reject);
-    });
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
+function matchesSurfacedMemoryLedgerFilter(record, filter) {
+  if (filter.surface && record.surface !== filter.surface) {
+    return false;
   }
-}
-function formatMemoryIndex(index) {
-  if (index.projects.length === 0) {
-    return "";
+  if (filter.source && record.source !== filter.source) {
+    return false;
   }
-  const lines = ["## Memory Index", ""];
-  for (const project of index.projects) {
-    const name = project.project ?? "(universal)";
-    const date = project.lastUpdated ? project.lastUpdated.slice(0, 10) : "unknown";
-    lines.push(`- ${name}: ${project.count} entries (last updated ${date})`);
+  if (filter.ownership && record.ownership !== filter.ownership) {
+    return false;
   }
-  lines.push("");
-  lines.push(`Total: ${index.totalEntries} entries`);
-  return lines.join("\n");
-}
-
-// src/edge/openclaw/recall.ts
-var RECALL_QUERY_MAX_CHARS = 500;
-var DEFAULT_LIMIT3 = 10;
-function resolveUpdateMetadata(isBrowse, isSessionStart, requestOverrides) {
-  const metadataMode = requestOverrides?.metadataMode ?? "non-browse";
-  return requestOverrides?.noUpdate !== true && !isBrowse && (metadataMode === "non-browse" || metadataMode === "session-start" && isSessionStart);
+  return true;
 }
-function resolveRuntimeDeps(executionOptions) {
-  return adaptLegacyRecallRuntimeDeps(executionOptions?.recallServiceDeps);
+function normalizeSurfacedMemoryLedgerInputs(inputs) {
+  const normalized = [];
+  const seenSignatures = /* @__PURE__ */ new Set();
+  for (const input of inputs) {
+    const entryId = normalizeSessionKey(input.entryId);
+    if (!entryId) {
+      continue;
+    }
+    const signature = [
+      entryId,
+      input.surface,
+      input.source,
+      input.ownership
+    ].join("\0");
+    if (seenSignatures.has(signature)) {
+      continue;
+    }
+    seenSignatures.add(signature);
+    normalized.push({
+      entryId,
+      surface: input.surface,
+      source: input.source,
+      ownership: input.ownership
+    });
+  }
+  return normalized;
 }
-function buildRecallRequest(budget, project, query, options) {
-  const isBrowse = options?.context === "browse";
-  const isSessionStart = options?.context === "session-start";
-  const trimmedQuery = query?.trim() ?? "";
-  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 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 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;
+function normalizeSessionSurfacedMemoryWrites(writes) {
+  const inputs = [];
+  for (const write of writes) {
+    for (const entryId of write.entryIds) {
+      inputs.push({
+        entryId,
+        surface: write.surface,
+        source: write.source,
+        ownership: write.ownership
+      });
+    }
+  }
+  return normalizeSurfacedMemoryLedgerInputs(inputs);
+}
+function resolveSessionSurfacedMemoryRecordProfile(profile) {
+  return { ...SESSION_SURFACED_MEMORY_RECORD_PROFILES[profile] };
+}
+function resolveSessionSurfacedMemoryIntent(intent) {
+  const definition = SESSION_SURFACED_MEMORY_INTENTS[intent];
   return {
-    isBrowse,
-    isSessionStart: !isBrowse && inferredSessionStart,
-    limit: options?.limit ?? DEFAULT_LIMIT3,
-    queryText,
-    since: options?.since,
-    types: options?.types,
-    until: options?.until,
-    around: options?.around,
-    aroundRadius: options?.aroundRadius,
-    platform: options?.platform,
-    minImportance: options?.minImportance,
-    expiry: options?.expiry,
-    universalOnly,
-    project: resolvedProject,
-    projectStrict: resolvedProjectStrict,
-    projectHints: resolvedProjectHints,
-    budget: isBrowse ? void 0 : options?.budget === null ? void 0 : options?.budget ?? budget
+    intent,
+    writeProfile: { ...definition.writeProfile },
+    readSelector: SESSION_SURFACED_MEMORY_SELECTORS.intent(intent),
+    sharedSelectors: [...definition.read.sharedSelectors],
+    lifecycle: { ...definition.lifecycle }
   };
 }
-function shapeRecallResult(result) {
+function resolveSessionSurfacedMemorySelectorFilter(selector) {
+  if (selector === "dedupe-relevant" || selector === "before-reset-owned") {
+    return { ...SESSION_SURFACED_MEMORY_SELECTOR_FILTERS[selector] };
+  }
+  if (selector.kind === "intent") {
+    return resolveSessionSurfacedMemoryIntent(selector.intent).writeProfile;
+  }
+  if (selector.kind === "profile") {
+    return resolveSessionSurfacedMemoryRecordProfile(selector.profile);
+  }
   return {
-    query: result.payload.query,
-    decision: result.payload.decision,
-    rollupSummary: result.payload.rollup_summary,
-    surfaceSelection: result.surfaceSelection,
-    results: result.payload.results.map((item) => ({
-      entry: item.entry,
-      score: item.score,
-      category: item.category
-    }))
+    source: selector.source
   };
 }
-async function runRecallStrict(budget, project, query, options, dbPath, executionOptions) {
-  return executeRecallRequest(
-    budget,
-    project,
-    query,
-    options,
-    dbPath,
-    executionOptions
-  );
+function normalizeSessionSurfacedMemoryIntentWrites(writes) {
+  const normalized = [];
+  for (const write of writes) {
+    normalized.push({
+      entryIds: write.entryIds,
+      ...resolveSessionSurfacedMemoryIntent(write.intent).writeProfile
+    });
+  }
+  return normalized;
 }
-async function executeRecallRequest(budget, project, query, options, dbPath, executionOptions) {
-  const request = buildRecallRequest(budget, project, query, options);
-  const runtime = resolveRuntimeDeps(executionOptions);
-  const updateMetadata = resolveUpdateMetadata(
-    request.isBrowse,
-    request.isSessionStart,
-    executionOptions?.requestOverrides
-  );
-  const result = request.isBrowse ? await browseRecall(
-    {
-      dbPath,
-      limit: request.limit,
-      threshold: 0,
-      types: request.types,
-      since: request.since,
-      until: request.until,
-      around: request.around,
-      aroundRadius: request.aroundRadius,
-      platform: request.platform,
-      minImportance: request.minImportance,
-      expiry: request.expiry,
-      project: request.project,
-      projectStrict: request.projectStrict,
-      projectHints: request.projectHints,
-      universalOnly: request.universalOnly,
-      includeRecallCounts: false
-    },
-    { runtime }
-  ) : request.isSessionStart ? await sessionStartRecall(
-    {
-      dbPath,
-      limit: request.limit,
-      budget: request.budget,
-      threshold: 0,
-      types: request.types,
-      since: request.since,
-      until: request.until,
-      around: request.around,
-      aroundRadius: request.aroundRadius,
-      platform: request.platform,
-      minImportance: request.minImportance,
-      expiry: request.expiry,
-      project: request.project,
-      projectStrict: request.projectStrict,
-      projectHints: request.projectHints,
-      universalOnly: request.universalOnly,
-      updateMetadata,
-      includeRecallCounts: false
-    },
-    { runtime }
-  ) : await searchRecall(
-    {
-      dbPath,
-      queryText: request.queryText,
-      queryContext: "default",
-      limit: request.limit,
-      budget: request.budget,
-      threshold: 0,
-      types: request.types,
-      since: request.since,
-      until: request.until,
-      around: request.around,
-      aroundRadius: request.aroundRadius,
-      platform: request.platform,
-      minImportance: request.minImportance,
-      expiry: request.expiry,
-      project: request.project,
-      projectStrict: request.projectStrict,
-      projectHints: request.projectHints,
-      universalOnly: request.universalOnly,
-      updateMetadata,
-      includeRecallCounts: false
-    },
-    { runtime }
-  );
-  return shapeRecallResult(result);
+function toSessionSurfacedMemoryWrites(writes) {
+  if (Symbol.iterator in Object(writes) && !("entryIds" in Object(writes))) {
+    return writes;
+  }
+  return [writes];
 }
-async function runRecall(budget, project, query, options, dbPath, executionOptions) {
-  try {
-    return await executeRecallRequest(budget, project, query, options, dbPath, executionOptions);
-  } catch {
-    return null;
+function toSessionSurfacedMemoryIntentWrites(writes) {
+  if (Symbol.iterator in Object(writes) && !("entryIds" in Object(writes))) {
+    return writes;
   }
+  return [writes];
 }
-async function fetchCoreEntries(coreProjects, dbPath, executionOptions) {
-  let result;
-  try {
-    result = shapeRecallResult(
-      await loadCoreRecall(
-        { dbPath },
-        { runtime: resolveRuntimeDeps(executionOptions) }
-      )
-    );
-  } catch {
-    return null;
+function registerSessionSurfacedMemoryAlias(store, aliasKey, sessionKey) {
+  const normalizedAlias = normalizeSessionKey(aliasKey);
+  const normalizedSessionKey = normalizeSessionKey(sessionKey);
+  if (!normalizedAlias || !normalizedSessionKey) {
+    return;
   }
-  const allowedProjects = new Set(
-    coreProjects.map((project) => project.trim()).filter((project) => project.length > 0)
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, normalizedSessionKey);
+  store.aliases.set(normalizedAlias, canonicalKey);
+  if (normalizedAlias === canonicalKey) {
+    return;
+  }
+  const aliasLedger = store.ledgers.get(normalizedAlias);
+  if (!aliasLedger) {
+    return;
+  }
+  store.ledgers.delete(normalizedAlias);
+  const targetLedger = getOrCreateSurfacedMemoryLedger(store, canonicalKey);
+  if (!targetLedger) {
+    return;
+  }
+  const existingSignatures = new Set(
+    targetLedger.records.map((record) => [record.entryId, record.surface, record.source, record.ownership].join("\0"))
   );
-  const filteredResults = result.results.filter((item) => {
-    const rawProject = item.entry?.project;
-    const project = typeof rawProject === "string" ? rawProject.trim() : "";
-    if (!project) {
-      return true;
-    }
-    return allowedProjects.has(project);
-  });
-  return {
-    ...result,
-    results: filteredResults.slice(0, 30)
-  };
-}
-
-// src/edge/openclaw/session-query.ts
-init_errors();
-init_guards();
-import { createReadStream as createReadStream2 } from "fs";
-import { readdir, stat } from "fs/promises";
-import path10 from "path";
-import { createInterface as createInterface2 } from "readline";
-var EXCHANGE_TEXT_MAX_CHARS = 200;
-var EXCHANGE_USER_TURN_LIMIT = 5;
-var RECENT_TURN_MAX_CHARS = 300;
-var DEFAULT_RECENT_TURN_LIMIT = 7;
-var SESSION_TRANSCRIPT_ARTIFACT_MARKERS = [".jsonl.reset.", ".jsonl.deleted."];
-function extractTextFromRoleMessage(message, role, separator) {
-  if (!isRecord(message) || message["role"] !== role) {
-    return "";
-  }
-  const content = message["content"];
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  const textParts = [];
-  for (const part of content) {
-    if (!isRecord(part) || part["type"] !== "text") {
+  for (const record of aliasLedger.records) {
+    const signature = [
+      record.entryId,
+      record.surface,
+      record.source,
+      record.ownership
+    ].join("\0");
+    if (existingSignatures.has(signature)) {
       continue;
     }
-    const partText = part["text"];
-    if (typeof partText !== "string") {
+    existingSignatures.add(signature);
+    targetLedger.records.push({
+      ...record,
+      sequence: targetLedger.nextSequence++
+    });
+  }
+  touchSurfacedMemoryLedger(store, canonicalKey);
+}
+function appendSessionSurfacedMemoryLedgerEntries(store, sessionKey, inputs) {
+  const ledger = getOrCreateSurfacedMemoryLedger(store, sessionKey);
+  if (!ledger) {
+    return 0;
+  }
+  const normalizedInputs = normalizeSurfacedMemoryLedgerInputs(inputs);
+  const existingSignatures = new Set(
+    ledger.records.map((record) => [record.entryId, record.surface, record.source, record.ownership].join("\0"))
+  );
+  let addedCount = 0;
+  for (const input of normalizedInputs) {
+    const signature = [
+      input.entryId,
+      input.surface,
+      input.source,
+      input.ownership
+    ].join("\0");
+    if (existingSignatures.has(signature)) {
       continue;
     }
-    const trimmed = partText.trim();
-    if (trimmed) {
-      textParts.push(trimmed);
-    }
+    existingSignatures.add(signature);
+    ledger.records.push({
+      ...input,
+      sequence: ledger.nextSequence++
+    });
+    addedCount += 1;
   }
-  return textParts.join(separator).trim();
+  if (addedCount > 0) {
+    touchSurfacedMemoryLedger(store, resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey));
+  }
+  return addedCount;
 }
-function extractTextFromUserMessage(message) {
-  return extractTextFromRoleMessage(message, "user", " ");
+function replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, inputs) {
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
+  if (!canonicalKey) {
+    return;
+  }
+  const normalizedInputs = normalizeSurfacedMemoryLedgerInputs(inputs);
+  const ledger = {
+    nextSequence: 1,
+    records: normalizedInputs.map((input, index) => ({
+      ...input,
+      sequence: index + 1
+    }))
+  };
+  ledger.nextSequence = ledger.records.length + 1;
+  store.ledgers.delete(canonicalKey);
+  store.ledgers.set(canonicalKey, ledger);
+  trimSurfacedMemoryLedgers(store);
 }
-function extractTextFromAssistantMessage(message) {
-  return extractTextFromRoleMessage(message, "assistant", " ");
+function recordSessionSurfacedMemory(store, sessionKey, writes, options = {}) {
+  const normalizedInputs = normalizeSessionSurfacedMemoryWrites(
+    toSessionSurfacedMemoryWrites(writes)
+  );
+  if (normalizedInputs.length === 0) {
+    if (options.mode === "replace") {
+      replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, []);
+    }
+    return 0;
+  }
+  if (options.mode === "replace") {
+    replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, normalizedInputs);
+    return normalizedInputs.length;
+  }
+  return appendSessionSurfacedMemoryLedgerEntries(store, sessionKey, normalizedInputs);
 }
-function truncateMessageText(text, maxChars = EXCHANGE_TEXT_MAX_CHARS) {
-  return text.length > maxChars ? text.slice(0, maxChars) : text;
+function recordSessionSurfacedMemoryByIntent(store, sessionKey, writes, options = {}) {
+  return recordSessionSurfacedMemory(
+    store,
+    sessionKey,
+    normalizeSessionSurfacedMemoryIntentWrites(
+      toSessionSurfacedMemoryIntentWrites(writes)
+    ),
+    options
+  );
 }
-function stripPromptMetadata(raw) {
-  if (!raw) {
-    return "";
+function getSessionSurfacedMemoryLedger(store, sessionKey) {
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
+  if (!canonicalKey) {
+    return [];
   }
-  try {
-    const pattern = /\[\w{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2} (?:[A-Z]{2,5}|GMT[+-]\d{1,2})\] /g;
-    let lastMatchEnd = -1;
-    let match = null;
-    while ((match = pattern.exec(raw)) !== null) {
-      lastMatchEnd = match.index + match[0].length;
-    }
-    if (lastMatchEnd >= 0) {
-      return raw.slice(lastMatchEnd).trim();
+  const ledger = store.ledgers.get(canonicalKey);
+  return ledger ? [...ledger.records] : [];
+}
+function getSessionSurfacedMemoryLedgerRecords(store, sessionKey, filter = {}) {
+  return getSessionSurfacedMemoryLedger(store, sessionKey).filter((record) => matchesSurfacedMemoryLedgerFilter(record, filter));
+}
+function collectSessionSurfacedMemoryEntryIds(records) {
+  const surfacedEntryIds = [];
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    if (seenEntryIds.has(record.entryId)) {
+      continue;
     }
-    return raw.trim();
-  } catch {
-    return "";
+    seenEntryIds.add(record.entryId);
+    surfacedEntryIds.push(record.entryId);
   }
+  return surfacedEntryIds;
 }
-function extractLastExchangeText(messages, maxTurns = EXCHANGE_USER_TURN_LIMIT) {
-  try {
-    if (!Array.isArray(messages) || messages.length === 0) {
-      return "";
-    }
-    if (maxTurns <= 0) {
-      return "";
-    }
-    const collected = [];
-    let collectedUserTurns = 0;
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-      const message = messages[index];
-      const userText = sanitizeTranscriptTurnText(extractTextFromUserMessage(message));
-      if (userText) {
-        collected.push({
-          role: "user",
-          text: truncateMessageText(userText.replace(/\s+/g, " ").trim())
-        });
-        collectedUserTurns += 1;
-        if (collectedUserTurns >= maxTurns) {
-          break;
-        }
-        continue;
-      }
-      const assistantText = sanitizeTranscriptTurnText(extractTextFromAssistantMessage(message));
-      if (assistantText) {
-        collected.push({
-          role: "assistant",
-          text: truncateMessageText(assistantText.replace(/\s+/g, " ").trim())
-        });
-      }
-    }
-    if (collected.length === 0) {
-      return "";
+function removeSessionSurfacedMemoryLedgerEntries(store, sessionKey, filter = {}) {
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
+  if (!canonicalKey) {
+    return 0;
+  }
+  const ledger = store.ledgers.get(canonicalKey);
+  if (!ledger) {
+    return 0;
+  }
+  const keptRecords = ledger.records.filter((record) => !matchesSurfacedMemoryLedgerFilter(record, filter));
+  const removedCount = ledger.records.length - keptRecords.length;
+  if (removedCount === 0) {
+    return 0;
+  }
+  if (keptRecords.length === 0) {
+    clearSessionSurfacedMemoryLedger(store, sessionKey);
+    return removedCount;
+  }
+  ledger.records = keptRecords;
+  touchSurfacedMemoryLedger(store, canonicalKey);
+  return removedCount;
+}
+function clearSessionSurfacedMemoryLedger(store, sessionKey) {
+  const normalizedKey = normalizeSessionKey(sessionKey);
+  if (!normalizedKey) {
+    return;
+  }
+  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, normalizedKey);
+  if (canonicalKey) {
+    store.ledgers.delete(canonicalKey);
+  }
+  for (const [alias, targetKey] of store.aliases) {
+    if (alias === normalizedKey || targetKey === canonicalKey) {
+      store.aliases.delete(alias);
     }
-    return collected.reverse().map((turn) => `${turn.role === "user" ? "U" : "A"}: ${turn.text}`).join(" | ");
-  } catch {
-    return "";
   }
 }
-async function listSessionFileCandidates(sessionsDir, currentSessionId, logger) {
-  try {
-    const normalizedSessionId = currentSessionId?.trim();
-    const entries = await readdir(sessionsDir, { withFileTypes: true });
-    const candidatePaths = [];
-    for (const entry of entries) {
-      if (!entry.isFile()) {
-        continue;
-      }
-      const isPlainJsonl = entry.name.endsWith(".jsonl");
-      const isTranscriptArtifact = SESSION_TRANSCRIPT_ARTIFACT_MARKERS.some((marker) => entry.name.includes(marker));
-      if (!isPlainJsonl && !isTranscriptArtifact) {
-        continue;
-      }
-      if (entry.name.includes(".deleted.") && !entry.name.includes(".jsonl.deleted.")) {
-        continue;
-      }
-      if (normalizedSessionId && entry.name.startsWith(normalizedSessionId)) {
-        continue;
-      }
-      candidatePaths.push(path10.join(sessionsDir, entry.name));
-    }
-    if (candidatePaths.length === 0) {
-      return [];
-    }
-    const statResults = await Promise.all(
-      candidatePaths.map(async (filePath) => {
-        try {
-          const fileStats = await stat(filePath);
-          return { filePath, mtimeMs: fileStats.mtimeMs };
-        } catch {
-          return null;
-        }
-      })
-    );
-    const candidates = statResults.filter(
-      (result) => result !== null
-    );
-    if (candidates.length === 0) {
-      return [];
-    }
-    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return candidates;
-  } catch (err) {
-    logger?.debug?.(
-      `listSessionFileCandidates: failed to read sessions dir "${sessionsDir}": ${toErrorMessage(err)}`
-    );
-    return [];
+var SURFACED_MEMORY_LIFECYCLE_FILTERS = {
+  commandResetCleared: {
+    ownership: "dedupe-only"
   }
+};
+function applySessionSurfacedMemoryCommandResetPolicy(store, sessionKey) {
+  return removeSessionSurfacedMemoryLedgerEntries(
+    store,
+    sessionKey,
+    SURFACED_MEMORY_LIFECYCLE_FILTERS.commandResetCleared
+  );
 }
-async function extractRecentTurnObjects(filePath, maxTurns = DEFAULT_RECENT_TURN_LIMIT) {
-  try {
-    if (!filePath) {
-      return [];
-    }
-    const parsedMaxTurns = Number.isFinite(maxTurns) ? Math.max(0, Math.trunc(maxTurns)) : 0;
-    if (parsedMaxTurns === 0) {
-      return [];
-    }
-    const allTurns = [];
-    await new Promise((resolve, reject) => {
-      const rl = createInterface2({
-        input: createReadStream2(filePath, { encoding: "utf8" }),
-        crlfDelay: Infinity
-      });
-      rl.on("line", (line) => {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          return;
-        }
-        let record;
-        try {
-          record = JSON.parse(trimmed);
-        } catch {
-          return;
-        }
-        if (!isRecord(record) || record["type"] !== "message") {
-          return;
-        }
-        const message = record["message"];
-        const messageTimestamp = isRecord(message) && typeof message["timestamp"] === "string" ? message["timestamp"] : void 0;
-        const timestamp2 = typeof record["timestamp"] === "string" ? record["timestamp"] : messageTimestamp;
-        const userText = extractTextFromRoleMessage(message, "user", "\n");
-        if (userText) {
-          allTurns.push({ role: "user", text: userText, timestamp: timestamp2 });
-          return;
-        }
-        const assistantText = extractTextFromRoleMessage(message, "assistant", "\n");
-        if (assistantText) {
-          allTurns.push({ role: "assistant", text: assistantText, timestamp: timestamp2 });
-        }
-      });
-      rl.on("close", resolve);
-      rl.on("error", reject);
-    });
-    const sanitizedTurns = sanitizeTranscriptTurns(allTurns, {
-      maxCharsPerTurn: RECENT_TURN_MAX_CHARS
-    });
-    return sanitizedTurns.slice(-parsedMaxTurns);
-  } catch {
-    return [];
-  }
+function applySessionSurfacedMemoryBeforeResetPolicy(store, sessionKey) {
+  const beforeResetOwnedEntryIds = querySessionSurfacedMemory(store, sessionKey).select(SESSION_SURFACED_MEMORY_SELECTORS.beforeResetOwned).entryIds();
+  const clearedCount = getSessionSurfacedMemoryLedger(store, sessionKey).length;
+  clearSessionSurfacedMemoryLedger(store, sessionKey);
+  return {
+    beforeResetOwnedEntryIds,
+    clearedCount
+  };
 }
-
-// src/edge/openclaw/session-state.ts
-init_errors();
-init_logger();
-
-// src/edge/openclaw/surfaced-memory-ledger.ts
-var MAX_RECALLED_SESSIONS = 200;
-var SESSION_SURFACED_MEMORY_INTENTS = {
-  startupPromptVisibleRecall: {
-    writeProfile: {
-      surface: "session-start",
-      source: "startup-prompt-visible",
-      ownership: "before-reset-owned"
-    },
-    read: {
-      sharedSelectors: ["dedupe-relevant", "before-reset-owned"]
-    },
-    lifecycle: {
-      ownership: "before-reset-owned",
-      commandReset: "preserve",
-      beforeResetFeedback: "owned"
+function querySessionSurfacedMemory(store, sessionKey) {
+  const records = (filter = {}) => getSessionSurfacedMemoryLedgerRecords(store, sessionKey, filter);
+  const entryIds = (filter = {}) => collectSessionSurfacedMemoryEntryIds(records(filter));
+  const hasEntry = (entryId, filter = {}) => {
+    const normalizedEntryId = normalizeSessionKey(entryId);
+    if (!normalizedEntryId) {
+      return false;
     }
-  },
-  midSessionPluginInjection: {
-    writeProfile: {
-      surface: "mid-session-recall",
-      source: "plugin-injection",
-      ownership: "dedupe-only"
-    },
-    read: {
-      sharedSelectors: ["dedupe-relevant"]
+    return records(filter).some((record) => record.entryId === normalizedEntryId);
+  };
+  const select = (selector) => {
+    const filter = resolveSessionSurfacedMemorySelectorFilter(selector);
+    return {
+      records: () => records(filter),
+      entryIds: () => entryIds(filter),
+      hasEntry: (entryId) => hasEntry(entryId, filter)
+    };
+  };
+  return {
+    records,
+    entryIds,
+    hasEntry,
+    select,
+    dedupeEntryIds() {
+      return select(SESSION_SURFACED_MEMORY_SELECTORS.dedupeRelevant).entryIds();
     },
-    lifecycle: {
-      ownership: "dedupe-only",
-      commandReset: "clear",
-      beforeResetFeedback: "excluded"
-    }
-  },
-  agentToolRecallOutput: {
-    writeProfile: {
-      surface: "agent-tool-recall",
-      source: "agent-tool-output",
-      ownership: "dedupe-only"
+    hasDedupeEntry(entryId) {
+      return select(SESSION_SURFACED_MEMORY_SELECTORS.dedupeRelevant).hasEntry(entryId);
     },
-    read: {
-      sharedSelectors: ["dedupe-relevant"]
+    beforeResetOwnedEntryIds() {
+      return select(SESSION_SURFACED_MEMORY_SELECTORS.beforeResetOwned).entryIds();
     },
-    lifecycle: {
-      ownership: "dedupe-only",
-      commandReset: "clear",
-      beforeResetFeedback: "excluded"
+    clearDedupeOnly() {
+      return removeSessionSurfacedMemoryLedgerEntries(store, sessionKey, {
+        ownership: "dedupe-only"
+      });
     }
+  };
+}
+
+// src/edge/openclaw/session-state.ts
+var SKIP_SESSION_PATTERNS = [":subagent:", ":cron:"];
+var DEFAULT_MAX_SEEN_SESSIONS = 1e3;
+var DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD = 0.85;
+var SEEN_SESSION_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var sessionStartLog = createLogger("session-start");
+var SESSION_STATE_GLOBALS_KEY = "__agenrOpenClawSessionState";
+function getSessionStateGlobals() {
+  const globalState = globalThis;
+  globalState[SESSION_STATE_GLOBALS_KEY] ??= {
+    seenSessions: /* @__PURE__ */ new Map(),
+    lastCleanupMs: 0,
+    surfacedMemoryLedgerStore: {
+      ledgers: /* @__PURE__ */ new Map(),
+      aliases: /* @__PURE__ */ new Map()
+    },
+    sessionSignalState: /* @__PURE__ */ new Map(),
+    handoffSeenSessionIds: /* @__PURE__ */ new Set(),
+    sessionRef: { current: "" }
+  };
+  return globalState[SESSION_STATE_GLOBALS_KEY];
+}
+var sessionStateGlobals = getSessionStateGlobals();
+var seenSessions = sessionStateGlobals.seenSessions;
+var ledgerStore = sessionStateGlobals.surfacedMemoryLedgerStore;
+var sessionRef = sessionStateGlobals.sessionRef;
+var sessionSignalState = sessionStateGlobals.sessionSignalState;
+var handoffSeenSessionIds = sessionStateGlobals.handoffSeenSessionIds;
+function registerSessionSurfacedMemoryAlias2(aliasKey, sessionKey) {
+  registerSessionSurfacedMemoryAlias(ledgerStore, aliasKey, sessionKey);
+}
+function recordSessionSurfacedMemoryByIntent2(sessionKey, writes, options = {}) {
+  return recordSessionSurfacedMemoryByIntent(ledgerStore, sessionKey, writes, options);
+}
+function querySessionSurfacedMemory2(sessionKey) {
+  return querySessionSurfacedMemory(ledgerStore, sessionKey);
+}
+function applySessionSurfacedMemoryCommandResetPolicy2(sessionKey) {
+  return applySessionSurfacedMemoryCommandResetPolicy(ledgerStore, sessionKey);
+}
+function applySessionSurfacedMemoryBeforeResetPolicy2(sessionKey) {
+  return applySessionSurfacedMemoryBeforeResetPolicy(ledgerStore, sessionKey);
+}
+function clearSessionSurfacedMemoryLedger2(sessionKey) {
+  clearSessionSurfacedMemoryLedger(ledgerStore, sessionKey);
+}
+function hasHandoffSession(sessionId) {
+  return handoffSeenSessionIds.has(sessionId);
+}
+function markHandoffSession(sessionId) {
+  handoffSeenSessionIds.add(sessionId);
+}
+function deleteHandoffSession(sessionId) {
+  handoffSeenSessionIds.delete(sessionId);
+}
+function resolveMaxSeenSessions() {
+  const raw = process.env.AGENR_OPENCLAW_MAX_SEEN_SESSIONS;
+  if (!raw) {
+    return DEFAULT_MAX_SEEN_SESSIONS;
   }
-};
-function buildSessionSurfacedMemoryRecordProfiles() {
-  const profiles = {};
-  for (const [intent, definition] of Object.entries(SESSION_SURFACED_MEMORY_INTENTS)) {
-    profiles[intent] = definition.writeProfile;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
   }
-  return profiles;
+  return DEFAULT_MAX_SEEN_SESSIONS;
 }
-var SESSION_SURFACED_MEMORY_RECORD_PROFILES = buildSessionSurfacedMemoryRecordProfiles();
-var SESSION_SURFACED_MEMORY_SELECTOR_FILTERS = {
-  "dedupe-relevant": {},
-  "before-reset-owned": { ownership: "before-reset-owned" }
-};
-var SESSION_SURFACED_MEMORY_SELECTORS = {
-  dedupeRelevant: "dedupe-relevant",
-  beforeResetOwned: "before-reset-owned",
-  intent(intent) {
-    return { kind: "intent", intent };
-  },
-  profile(profile) {
-    return { kind: "profile", profile };
-  },
-  source(source) {
-    return { kind: "source", source };
+function canExecuteSql(db) {
+  return typeof db?.execute === "function";
+}
+function trimSeenSessionCache() {
+  const maxSeenSessions = resolveMaxSeenSessions();
+  while (seenSessions.size > maxSeenSessions) {
+    const oldestKey = seenSessions.keys().next().value;
+    if (oldestKey === void 0) {
+      break;
+    }
+    seenSessions.delete(oldestKey);
+  }
+}
+function touchSeenSessionCache(sessionKey) {
+  seenSessions.delete(sessionKey);
+  seenSessions.set(sessionKey, true);
+  trimSeenSessionCache();
+}
+async function hasSeenSessionInDb(db, sessionKey) {
+  const result = await db.execute({
+    sql: "SELECT 1 FROM seen_sessions WHERE dedupe_key = ? AND seen_at >= ? LIMIT 1",
+    args: [sessionKey, Date.now() - SEEN_SESSION_RETENTION_MS]
+  });
+  return result.rows.length > 0;
+}
+async function cleanupSeenSessionsInDb(db, nowMs) {
+  const maxSeenSessions = resolveMaxSeenSessions();
+  await db.execute({
+    sql: "DELETE FROM seen_sessions WHERE seen_at < ?",
+    args: [nowMs - SEEN_SESSION_RETENTION_MS]
+  });
+  await db.execute({
+    sql: `
+      DELETE FROM seen_sessions
+      WHERE dedupe_key IN (
+        SELECT dedupe_key
+        FROM seen_sessions
+        ORDER BY seen_at DESC, dedupe_key DESC
+        LIMIT -1 OFFSET ?
+      )
+    `,
+    args: [maxSeenSessions]
+  });
+}
+function shouldSkipSession(sessionKey) {
+  return SKIP_SESSION_PATTERNS.some((pattern) => sessionKey.includes(pattern));
+}
+async function hasSeenSession(sessionKey, db) {
+  let seen = seenSessions.has(sessionKey);
+  if (seen) {
+    touchSeenSessionCache(sessionKey);
+    sessionStartLog.debug(
+      `hasSeenSession key=${sessionKey.slice(0, 12)} found=${seen} mapSize=${seenSessions.size}`
+    );
+    return true;
   }
-};
-function normalizeSessionKey(value) {
-  return value.trim();
-}
-function trimSurfacedMemoryLedgers(store) {
-  while (store.ledgers.size > MAX_RECALLED_SESSIONS) {
-    const oldestKey = store.ledgers.keys().next().value;
-    if (oldestKey === void 0) {
-      break;
-    }
-    store.ledgers.delete(oldestKey);
-    for (const [alias, canonicalKey] of store.aliases) {
-      if (canonicalKey === oldestKey) {
-        store.aliases.delete(alias);
+  if (canExecuteSql(db)) {
+    try {
+      seen = await hasSeenSessionInDb(db, sessionKey);
+      if (seen) {
+        touchSeenSessionCache(sessionKey);
       }
+    } catch (err) {
+      sessionStartLog.warn(`hasSeenSession db lookup failed: ${toErrorMessage(err)}`);
     }
   }
+  sessionStartLog.debug(
+    `hasSeenSession key=${sessionKey.slice(0, 12)} found=${seen} mapSize=${seenSessions.size}`
+  );
+  return seen;
 }
-function touchSurfacedMemoryLedger(store, canonicalKey) {
-  const existing = store.ledgers.get(canonicalKey);
-  if (!existing) {
+async function markSessionSeen(sessionKey, db) {
+  touchSeenSessionCache(sessionKey);
+  if (!canExecuteSql(db)) {
     return;
   }
-  store.ledgers.delete(canonicalKey);
-  store.ledgers.set(canonicalKey, existing);
-}
-function resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey) {
-  const normalizedKey = normalizeSessionKey(sessionKey);
-  if (!normalizedKey) {
-    return "";
-  }
-  return store.aliases.get(normalizedKey) ?? normalizedKey;
-}
-function getOrCreateSurfacedMemoryLedger(store, sessionKey) {
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
-  if (!canonicalKey) {
-    return null;
-  }
-  const existing = store.ledgers.get(canonicalKey);
-  if (existing) {
-    touchSurfacedMemoryLedger(store, canonicalKey);
-    return existing;
+  const nowMs = Date.now();
+  try {
+    await db.execute({
+      sql: "INSERT OR REPLACE INTO seen_sessions (dedupe_key, seen_at) VALUES (?, ?)",
+      args: [sessionKey, nowMs]
+    });
+    if (nowMs - sessionStateGlobals.lastCleanupMs > CLEANUP_INTERVAL_MS) {
+      await cleanupSeenSessionsInDb(db, nowMs);
+      sessionStateGlobals.lastCleanupMs = nowMs;
+    }
+  } catch (err) {
+    sessionStartLog.warn(`markSessionSeen db write failed: ${toErrorMessage(err)}`);
   }
-  const ledger = {
-    nextSequence: 1,
-    records: []
-  };
-  store.ledgers.set(canonicalKey, ledger);
-  trimSurfacedMemoryLedgers(store);
-  return ledger;
 }
-function matchesSurfacedMemoryLedgerFilter(record, filter) {
-  if (filter.surface && record.surface !== filter.surface) {
-    return false;
-  }
-  if (filter.source && record.source !== filter.source) {
-    return false;
-  }
-  if (filter.ownership && record.ownership !== filter.ownership) {
-    return false;
+function resolveMidSessionLimit(raw, fallback) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return fallback;
   }
-  return true;
-}
-function normalizeSurfacedMemoryLedgerInputs(inputs) {
-  const normalized = [];
-  const seenSignatures = /* @__PURE__ */ new Set();
-  for (const input of inputs) {
-    const entryId = normalizeSessionKey(input.entryId);
-    if (!entryId) {
-      continue;
-    }
-    const signature = [
-      entryId,
-      input.surface,
-      input.source,
-      input.ownership
-    ].join("\0");
-    if (seenSignatures.has(signature)) {
-      continue;
-    }
-    seenSignatures.add(signature);
-    normalized.push({
-      entryId,
-      surface: input.surface,
-      source: input.source,
-      ownership: input.ownership
-    });
+  const normalized = Math.trunc(raw);
+  if (normalized <= 0) {
+    return fallback;
   }
   return normalized;
 }
-function normalizeSessionSurfacedMemoryWrites(writes) {
-  const inputs = [];
-  for (const write of writes) {
-    for (const entryId of write.entryIds) {
-      inputs.push({
-        entryId,
-        surface: write.surface,
-        source: write.source,
-        ownership: write.ownership
-      });
-    }
+function resolveMidSessionSimilarityThreshold(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD;
   }
-  return normalizeSurfacedMemoryLedgerInputs(inputs);
-}
-function resolveSessionSurfacedMemoryRecordProfile(profile) {
-  return { ...SESSION_SURFACED_MEMORY_RECORD_PROFILES[profile] };
+  if (raw < 0 || raw > 1) {
+    return DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD;
+  }
+  return raw;
 }
-function resolveSessionSurfacedMemoryIntent(intent) {
-  const definition = SESSION_SURFACED_MEMORY_INTENTS[intent];
-  return {
-    intent,
-    writeProfile: { ...definition.writeProfile },
-    readSelector: SESSION_SURFACED_MEMORY_SELECTORS.intent(intent),
-    sharedSelectors: [...definition.read.sharedSelectors],
-    lifecycle: { ...definition.lifecycle }
-  };
+function clearSessionState() {
+  seenSessions.clear();
+  sessionStateGlobals.lastCleanupMs = 0;
+  sessionSignalState.clear();
+  handoffSeenSessionIds.clear();
+  ledgerStore.ledgers.clear();
+  ledgerStore.aliases.clear();
+  sessionRef.current = "";
 }
-function resolveSessionSurfacedMemorySelectorFilter(selector) {
-  if (selector === "dedupe-relevant" || selector === "before-reset-owned") {
-    return { ...SESSION_SURFACED_MEMORY_SELECTOR_FILTERS[selector] };
-  }
-  if (selector.kind === "intent") {
-    return resolveSessionSurfacedMemoryIntent(selector.intent).writeProfile;
+
+// src/edge/openclaw/memory-index.ts
+init_inbound();
+init_errors();
+var MEMORY_INDEX_TIMEOUT_MS = 1e4;
+var MEMORY_INDEX_TIMEOUT = /* @__PURE__ */ Symbol("memory-index-timeout");
+function normalizeDate(value) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!raw) {
+    return "";
   }
-  if (selector.kind === "profile") {
-    return resolveSessionSurfacedMemoryRecordProfile(selector.profile);
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    return raw;
   }
-  return {
-    source: selector.source
-  };
+  return parsed.toISOString();
 }
-function normalizeSessionSurfacedMemoryIntentWrites(writes) {
-  const normalized = [];
-  for (const write of writes) {
-    normalized.push({
-      entryIds: write.entryIds,
-      ...resolveSessionSurfacedMemoryIntent(write.intent).writeProfile
-    });
+function toProjectName(value) {
+  if (value === null || value === void 0) {
+    return null;
   }
-  return normalized;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
 }
-function toSessionSurfacedMemoryWrites(writes) {
-  if (Symbol.iterator in Object(writes) && !("entryIds" in Object(writes))) {
-    return writes;
+function toCount(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 0;
   }
-  return [writes];
+  return Math.floor(parsed);
 }
-function toSessionSurfacedMemoryIntentWrites(writes) {
-  if (Symbol.iterator in Object(writes) && !("entryIds" in Object(writes))) {
-    return writes;
+function normalizeProjectIndexEntry(value) {
+  if (!value || typeof value !== "object") {
+    return null;
   }
-  return [writes];
+  const row = value;
+  return {
+    project: toProjectName(row.project),
+    count: toCount(row.count),
+    lastUpdated: normalizeDate(row.lastUpdated ?? row.last_updated)
+  };
 }
-function registerSessionSurfacedMemoryAlias(store, aliasKey, sessionKey) {
-  const normalizedAlias = normalizeSessionKey(aliasKey);
-  const normalizedSessionKey = normalizeSessionKey(sessionKey);
-  if (!normalizedAlias || !normalizedSessionKey) {
-    return;
-  }
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, normalizedSessionKey);
-  store.aliases.set(normalizedAlias, canonicalKey);
-  if (normalizedAlias === canonicalKey) {
-    return;
-  }
-  const aliasLedger = store.ledgers.get(normalizedAlias);
-  if (!aliasLedger) {
-    return;
+function parseMemoryIndex(value) {
+  if (!value || typeof value !== "object") {
+    return null;
   }
-  store.ledgers.delete(normalizedAlias);
-  const targetLedger = getOrCreateSurfacedMemoryLedger(store, canonicalKey);
-  if (!targetLedger) {
-    return;
+  const response = value;
+  if (!Array.isArray(response.projects)) {
+    return null;
   }
-  const existingSignatures = new Set(
-    targetLedger.records.map((record) => [record.entryId, record.surface, record.source, record.ownership].join("\0"))
-  );
-  for (const record of aliasLedger.records) {
-    const signature = [
-      record.entryId,
-      record.surface,
-      record.source,
-      record.ownership
-    ].join("\0");
-    if (existingSignatures.has(signature)) {
-      continue;
+  const projects = response.projects.map((entry) => normalizeProjectIndexEntry(entry)).filter((entry) => entry !== null);
+  const totalFromResponse = Number(response.totalEntries);
+  const totalEntries = Number.isFinite(totalFromResponse) && totalFromResponse >= 0 ? Math.floor(totalFromResponse) : projects.reduce((sum, project) => sum + project.count, 0);
+  return { projects, totalEntries };
+}
+async function runMemoryIndex(dbPath, executionOptions) {
+  try {
+    const timeoutMs = executionOptions?.timeoutMs ?? MEMORY_INDEX_TIMEOUT_MS;
+    const result = await withTimeout(
+      loadMemoryIndex(dbPath, executionOptions?.recallServiceDeps),
+      timeoutMs
+    );
+    if (result === MEMORY_INDEX_TIMEOUT) {
+      return { status: "timeout" };
     }
-    existingSignatures.add(signature);
-    targetLedger.records.push({
-      ...record,
-      sequence: targetLedger.nextSequence++
-    });
+    return result;
+  } catch (error) {
+    return {
+      status: "error",
+      error: toErrorMessage(error)
+    };
   }
-  touchSurfacedMemoryLedger(store, canonicalKey);
 }
-function appendSessionSurfacedMemoryLedgerEntries(store, sessionKey, inputs) {
-  const ledger = getOrCreateSurfacedMemoryLedger(store, sessionKey);
-  if (!ledger) {
-    return 0;
-  }
-  const normalizedInputs = normalizeSurfacedMemoryLedgerInputs(inputs);
-  const existingSignatures = new Set(
-    ledger.records.map((record) => [record.entryId, record.surface, record.source, record.ownership].join("\0"))
+async function loadMemoryIndex(dbPath, recallServiceDeps) {
+  const index = parseMemoryIndex(
+    await buildRecallIndex(
+      { dbPath },
+      { runtime: adaptLegacyRecallRuntimeDeps(recallServiceDeps) }
+    )
   );
-  let addedCount = 0;
-  for (const input of normalizedInputs) {
-    const signature = [
-      input.entryId,
-      input.surface,
-      input.source,
-      input.ownership
-    ].join("\0");
-    if (existingSignatures.has(signature)) {
-      continue;
-    }
-    existingSignatures.add(signature);
-    ledger.records.push({
-      ...input,
-      sequence: ledger.nextSequence++
+  if (!index) {
+    return { status: "invalid" };
+  }
+  return {
+    status: "ok",
+    index
+  };
+}
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        resolve(MEMORY_INDEX_TIMEOUT);
+      }, timeoutMs);
+      promise.then(resolve).catch(reject);
     });
-    addedCount += 1;
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
   }
-  if (addedCount > 0) {
-    touchSurfacedMemoryLedger(store, resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey));
+}
+function formatMemoryIndex(index) {
+  if (index.projects.length === 0) {
+    return "";
   }
-  return addedCount;
+  const lines = ["## Memory Index", ""];
+  for (const project of index.projects) {
+    const name = project.project ?? "(universal)";
+    const date = project.lastUpdated ? project.lastUpdated.slice(0, 10) : "unknown";
+    lines.push(`- ${name}: ${project.count} entries (last updated ${date})`);
+  }
+  lines.push("");
+  lines.push(`Total: ${index.totalEntries} entries`);
+  return lines.join("\n");
 }
-function replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, inputs) {
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
-  if (!canonicalKey) {
-    return;
+
+// src/edge/openclaw/recall.ts
+var RECALL_QUERY_MAX_CHARS = 500;
+var DEFAULT_LIMIT3 = 10;
+function resolveUpdateMetadata(isBrowse, isSessionStart, requestOverrides) {
+  const metadataMode = requestOverrides?.metadataMode ?? "non-browse";
+  return requestOverrides?.noUpdate !== true && !isBrowse && (metadataMode === "non-browse" || metadataMode === "session-start" && isSessionStart);
+}
+function resolveRuntimeDeps(executionOptions) {
+  return adaptLegacyRecallRuntimeDeps(executionOptions?.recallServiceDeps);
+}
+function resolveRecallMetadata(requestOverrides) {
+  if (requestOverrides?.metadata) {
+    return requestOverrides.metadata;
   }
-  const normalizedInputs = normalizeSurfacedMemoryLedgerInputs(inputs);
-  const ledger = {
-    nextSequence: 1,
-    records: normalizedInputs.map((input, index) => ({
-      ...input,
-      sequence: index + 1
+  const sessionId = sessionRef.current.trim();
+  if (!sessionId) {
+    return void 0;
+  }
+  return {
+    sessionId,
+    platform: "openclaw"
+  };
+}
+function buildRecallRequest(budget, project, query, options) {
+  const isBrowse = options?.context === "browse";
+  const isSessionStart = options?.context === "session-start";
+  const trimmedQuery = query?.trim() ?? "";
+  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 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 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_LIMIT3,
+    queryText,
+    since: options?.since,
+    types: options?.types,
+    until: options?.until,
+    around: options?.around,
+    aroundRadius: options?.aroundRadius,
+    platform: options?.platform,
+    minImportance: options?.minImportance,
+    expiry: options?.expiry,
+    universalOnly,
+    project: resolvedProject,
+    projectStrict: resolvedProjectStrict,
+    projectHints: resolvedProjectHints,
+    budget: isBrowse ? void 0 : options?.budget === null ? void 0 : options?.budget ?? budget
+  };
+}
+function shapeRecallResult(result) {
+  return {
+    query: result.payload.query,
+    decision: result.payload.decision,
+    rollupSummary: result.payload.rollup_summary,
+    surfaceSelection: result.surfaceSelection,
+    results: result.payload.results.map((item) => ({
+      entry: item.entry,
+      score: item.score,
+      category: item.category
     }))
   };
-  ledger.nextSequence = ledger.records.length + 1;
-  store.ledgers.delete(canonicalKey);
-  store.ledgers.set(canonicalKey, ledger);
-  trimSurfacedMemoryLedgers(store);
 }
-function recordSessionSurfacedMemory(store, sessionKey, writes, options = {}) {
-  const normalizedInputs = normalizeSessionSurfacedMemoryWrites(
-    toSessionSurfacedMemoryWrites(writes)
+async function runRecallStrict(budget, project, query, options, dbPath, executionOptions) {
+  return executeRecallRequest(
+    budget,
+    project,
+    query,
+    options,
+    dbPath,
+    executionOptions
   );
-  if (normalizedInputs.length === 0) {
-    if (options.mode === "replace") {
-      replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, []);
-    }
-    return 0;
-  }
-  if (options.mode === "replace") {
-    replaceSessionSurfacedMemoryLedgerEntries(store, sessionKey, normalizedInputs);
-    return normalizedInputs.length;
-  }
-  return appendSessionSurfacedMemoryLedgerEntries(store, sessionKey, normalizedInputs);
 }
-function recordSessionSurfacedMemoryByIntent(store, sessionKey, writes, options = {}) {
-  return recordSessionSurfacedMemory(
-    store,
-    sessionKey,
-    normalizeSessionSurfacedMemoryIntentWrites(
-      toSessionSurfacedMemoryIntentWrites(writes)
-    ),
-    options
+async function executeRecallRequest(budget, project, query, options, dbPath, executionOptions) {
+  const request = buildRecallRequest(budget, project, query, options);
+  const runtime = resolveRuntimeDeps(executionOptions);
+  const updateMetadata = resolveUpdateMetadata(
+    request.isBrowse,
+    request.isSessionStart,
+    executionOptions?.requestOverrides
+  );
+  const metadata = resolveRecallMetadata(executionOptions?.requestOverrides);
+  const result = request.isBrowse ? await browseRecall(
+    {
+      dbPath,
+      limit: request.limit,
+      threshold: 0,
+      types: request.types,
+      since: request.since,
+      until: request.until,
+      around: request.around,
+      aroundRadius: request.aroundRadius,
+      platform: request.platform,
+      minImportance: request.minImportance,
+      expiry: request.expiry,
+      project: request.project,
+      projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
+      universalOnly: request.universalOnly,
+      includeRecallCounts: false
+    },
+    { runtime }
+  ) : request.isSessionStart ? await sessionStartRecall(
+    {
+      dbPath,
+      limit: request.limit,
+      budget: request.budget,
+      threshold: 0,
+      types: request.types,
+      since: request.since,
+      until: request.until,
+      around: request.around,
+      aroundRadius: request.aroundRadius,
+      platform: request.platform,
+      minImportance: request.minImportance,
+      expiry: request.expiry,
+      project: request.project,
+      projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
+      universalOnly: request.universalOnly,
+      updateMetadata,
+      metadata,
+      includeRecallCounts: false
+    },
+    { runtime }
+  ) : await searchRecall(
+    {
+      dbPath,
+      queryText: request.queryText,
+      queryContext: "default",
+      limit: request.limit,
+      budget: request.budget,
+      threshold: 0,
+      types: request.types,
+      since: request.since,
+      until: request.until,
+      around: request.around,
+      aroundRadius: request.aroundRadius,
+      platform: request.platform,
+      minImportance: request.minImportance,
+      expiry: request.expiry,
+      project: request.project,
+      projectStrict: request.projectStrict,
+      projectHints: request.projectHints,
+      universalOnly: request.universalOnly,
+      updateMetadata,
+      metadata,
+      includeRecallCounts: false
+    },
+    { runtime }
   );
+  return shapeRecallResult(result);
 }
-function getSessionSurfacedMemoryLedger(store, sessionKey) {
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
-  if (!canonicalKey) {
-    return [];
-  }
-  const ledger = store.ledgers.get(canonicalKey);
-  return ledger ? [...ledger.records] : [];
-}
-function getSessionSurfacedMemoryLedgerRecords(store, sessionKey, filter = {}) {
-  return getSessionSurfacedMemoryLedger(store, sessionKey).filter((record) => matchesSurfacedMemoryLedgerFilter(record, filter));
-}
-function collectSessionSurfacedMemoryEntryIds(records) {
-  const surfacedEntryIds = [];
-  const seenEntryIds = /* @__PURE__ */ new Set();
-  for (const record of records) {
-    if (seenEntryIds.has(record.entryId)) {
-      continue;
-    }
-    seenEntryIds.add(record.entryId);
-    surfacedEntryIds.push(record.entryId);
-  }
-  return surfacedEntryIds;
-}
-function removeSessionSurfacedMemoryLedgerEntries(store, sessionKey, filter = {}) {
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, sessionKey);
-  if (!canonicalKey) {
-    return 0;
-  }
-  const ledger = store.ledgers.get(canonicalKey);
-  if (!ledger) {
-    return 0;
-  }
-  const keptRecords = ledger.records.filter((record) => !matchesSurfacedMemoryLedgerFilter(record, filter));
-  const removedCount = ledger.records.length - keptRecords.length;
-  if (removedCount === 0) {
-    return 0;
-  }
-  if (keptRecords.length === 0) {
-    clearSessionSurfacedMemoryLedger(store, sessionKey);
-    return removedCount;
-  }
-  ledger.records = keptRecords;
-  touchSurfacedMemoryLedger(store, canonicalKey);
-  return removedCount;
-}
-function clearSessionSurfacedMemoryLedger(store, sessionKey) {
-  const normalizedKey = normalizeSessionKey(sessionKey);
-  if (!normalizedKey) {
-    return;
-  }
-  const canonicalKey = resolveCanonicalSurfacedMemoryLedgerKey(store, normalizedKey);
-  if (canonicalKey) {
-    store.ledgers.delete(canonicalKey);
-  }
-  for (const [alias, targetKey] of store.aliases) {
-    if (alias === normalizedKey || targetKey === canonicalKey) {
-      store.aliases.delete(alias);
-    }
+async function runRecall(budget, project, query, options, dbPath, executionOptions) {
+  try {
+    return await executeRecallRequest(budget, project, query, options, dbPath, executionOptions);
+  } catch {
+    return null;
   }
 }
-var SURFACED_MEMORY_LIFECYCLE_FILTERS = {
-  commandResetCleared: {
-    ownership: "dedupe-only"
+async function fetchCoreEntries(coreProjects, dbPath, executionOptions) {
+  let result;
+  try {
+    result = shapeRecallResult(
+      await loadCoreRecall(
+        { dbPath },
+        { runtime: resolveRuntimeDeps(executionOptions) }
+      )
+    );
+  } catch {
+    return null;
   }
-};
-function applySessionSurfacedMemoryCommandResetPolicy(store, sessionKey) {
-  return removeSessionSurfacedMemoryLedgerEntries(
-    store,
-    sessionKey,
-    SURFACED_MEMORY_LIFECYCLE_FILTERS.commandResetCleared
+  const allowedProjects = new Set(
+    coreProjects.map((project) => project.trim()).filter((project) => project.length > 0)
   );
-}
-function applySessionSurfacedMemoryBeforeResetPolicy(store, sessionKey) {
-  const beforeResetOwnedEntryIds = querySessionSurfacedMemory(store, sessionKey).select(SESSION_SURFACED_MEMORY_SELECTORS.beforeResetOwned).entryIds();
-  const clearedCount = getSessionSurfacedMemoryLedger(store, sessionKey).length;
-  clearSessionSurfacedMemoryLedger(store, sessionKey);
-  return {
-    beforeResetOwnedEntryIds,
-    clearedCount
-  };
-}
-function querySessionSurfacedMemory(store, sessionKey) {
-  const records = (filter = {}) => getSessionSurfacedMemoryLedgerRecords(store, sessionKey, filter);
-  const entryIds = (filter = {}) => collectSessionSurfacedMemoryEntryIds(records(filter));
-  const hasEntry = (entryId, filter = {}) => {
-    const normalizedEntryId = normalizeSessionKey(entryId);
-    if (!normalizedEntryId) {
-      return false;
+  const filteredResults = result.results.filter((item) => {
+    const rawProject = item.entry?.project;
+    const project = typeof rawProject === "string" ? rawProject.trim() : "";
+    if (!project) {
+      return true;
     }
-    return records(filter).some((record) => record.entryId === normalizedEntryId);
-  };
-  const select = (selector) => {
-    const filter = resolveSessionSurfacedMemorySelectorFilter(selector);
-    return {
-      records: () => records(filter),
-      entryIds: () => entryIds(filter),
-      hasEntry: (entryId) => hasEntry(entryId, filter)
-    };
-  };
+    return allowedProjects.has(project);
+  });
   return {
-    records,
-    entryIds,
-    hasEntry,
-    select,
-    dedupeEntryIds() {
-      return select(SESSION_SURFACED_MEMORY_SELECTORS.dedupeRelevant).entryIds();
-    },
-    hasDedupeEntry(entryId) {
-      return select(SESSION_SURFACED_MEMORY_SELECTORS.dedupeRelevant).hasEntry(entryId);
-    },
-    beforeResetOwnedEntryIds() {
-      return select(SESSION_SURFACED_MEMORY_SELECTORS.beforeResetOwned).entryIds();
-    },
-    clearDedupeOnly() {
-      return removeSessionSurfacedMemoryLedgerEntries(store, sessionKey, {
-        ownership: "dedupe-only"
-      });
-    }
+    ...result,
+    results: filteredResults.slice(0, 30)
   };
 }
 
-// src/edge/openclaw/session-state.ts
-var SKIP_SESSION_PATTERNS = [":subagent:", ":cron:"];
-var DEFAULT_MAX_SEEN_SESSIONS = 1e3;
-var DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD = 0.85;
-var SEEN_SESSION_RETENTION_MS = 24 * 60 * 60 * 1e3;
-var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
-var sessionStartLog = createLogger("session-start");
-var SESSION_STATE_GLOBALS_KEY = "__agenrOpenClawSessionState";
-function getSessionStateGlobals() {
-  const globalState = globalThis;
-  globalState[SESSION_STATE_GLOBALS_KEY] ??= {
-    seenSessions: /* @__PURE__ */ new Map(),
-    lastCleanupMs: 0,
-    surfacedMemoryLedgerStore: {
-      ledgers: /* @__PURE__ */ new Map(),
-      aliases: /* @__PURE__ */ new Map()
-    },
-    sessionSignalState: /* @__PURE__ */ new Map(),
-    handoffSeenSessionIds: /* @__PURE__ */ new Set(),
-    sessionRef: { current: "" }
-  };
-  return globalState[SESSION_STATE_GLOBALS_KEY];
-}
-var sessionStateGlobals = getSessionStateGlobals();
-var seenSessions = sessionStateGlobals.seenSessions;
-var ledgerStore = sessionStateGlobals.surfacedMemoryLedgerStore;
-var sessionRef = sessionStateGlobals.sessionRef;
-var sessionSignalState = sessionStateGlobals.sessionSignalState;
-var handoffSeenSessionIds = sessionStateGlobals.handoffSeenSessionIds;
-function registerSessionSurfacedMemoryAlias2(aliasKey, sessionKey) {
-  registerSessionSurfacedMemoryAlias(ledgerStore, aliasKey, sessionKey);
-}
-function recordSessionSurfacedMemoryByIntent2(sessionKey, writes, options = {}) {
-  return recordSessionSurfacedMemoryByIntent(ledgerStore, sessionKey, writes, options);
-}
-function querySessionSurfacedMemory2(sessionKey) {
-  return querySessionSurfacedMemory(ledgerStore, sessionKey);
-}
-function applySessionSurfacedMemoryCommandResetPolicy2(sessionKey) {
-  return applySessionSurfacedMemoryCommandResetPolicy(ledgerStore, sessionKey);
-}
-function applySessionSurfacedMemoryBeforeResetPolicy2(sessionKey) {
-  return applySessionSurfacedMemoryBeforeResetPolicy(ledgerStore, sessionKey);
-}
-function clearSessionSurfacedMemoryLedger2(sessionKey) {
-  clearSessionSurfacedMemoryLedger(ledgerStore, sessionKey);
-}
-function hasHandoffSession(sessionId) {
-  return handoffSeenSessionIds.has(sessionId);
-}
-function markHandoffSession(sessionId) {
-  handoffSeenSessionIds.add(sessionId);
-}
-function deleteHandoffSession(sessionId) {
-  handoffSeenSessionIds.delete(sessionId);
-}
-function resolveMaxSeenSessions() {
-  const raw = process.env.AGENR_OPENCLAW_MAX_SEEN_SESSIONS;
-  if (!raw) {
-    return DEFAULT_MAX_SEEN_SESSIONS;
+// src/edge/openclaw/session-query.ts
+init_errors();
+init_guards();
+import { createReadStream as createReadStream2 } from "fs";
+import { readdir, stat } from "fs/promises";
+import path10 from "path";
+import { createInterface as createInterface2 } from "readline";
+var EXCHANGE_TEXT_MAX_CHARS = 200;
+var EXCHANGE_USER_TURN_LIMIT = 5;
+var RECENT_TURN_MAX_CHARS = 300;
+var DEFAULT_RECENT_TURN_LIMIT = 7;
+var SESSION_TRANSCRIPT_ARTIFACT_MARKERS = [".jsonl.reset.", ".jsonl.deleted."];
+function extractTextFromRoleMessage(message, role, separator) {
+  if (!isRecord(message) || message["role"] !== role) {
+    return "";
   }
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isFinite(parsed) && parsed > 0) {
-    return parsed;
+  const content = message["content"];
+  if (typeof content === "string") {
+    return content.trim();
   }
-  return DEFAULT_MAX_SEEN_SESSIONS;
-}
-function canExecuteSql(db) {
-  return typeof db?.execute === "function";
-}
-function trimSeenSessionCache() {
-  const maxSeenSessions = resolveMaxSeenSessions();
-  while (seenSessions.size > maxSeenSessions) {
-    const oldestKey = seenSessions.keys().next().value;
-    if (oldestKey === void 0) {
-      break;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const textParts = [];
+  for (const part of content) {
+    if (!isRecord(part) || part["type"] !== "text") {
+      continue;
+    }
+    const partText = part["text"];
+    if (typeof partText !== "string") {
+      continue;
+    }
+    const trimmed = partText.trim();
+    if (trimmed) {
+      textParts.push(trimmed);
     }
-    seenSessions.delete(oldestKey);
   }
+  return textParts.join(separator).trim();
 }
-function touchSeenSessionCache(sessionKey) {
-  seenSessions.delete(sessionKey);
-  seenSessions.set(sessionKey, true);
-  trimSeenSessionCache();
-}
-async function hasSeenSessionInDb(db, sessionKey) {
-  const result = await db.execute({
-    sql: "SELECT 1 FROM seen_sessions WHERE dedupe_key = ? AND seen_at >= ? LIMIT 1",
-    args: [sessionKey, Date.now() - SEEN_SESSION_RETENTION_MS]
-  });
-  return result.rows.length > 0;
+function extractTextFromUserMessage(message) {
+  return extractTextFromRoleMessage(message, "user", " ");
 }
-async function cleanupSeenSessionsInDb(db, nowMs) {
-  const maxSeenSessions = resolveMaxSeenSessions();
-  await db.execute({
-    sql: "DELETE FROM seen_sessions WHERE seen_at < ?",
-    args: [nowMs - SEEN_SESSION_RETENTION_MS]
-  });
-  await db.execute({
-    sql: `
-      DELETE FROM seen_sessions
-      WHERE dedupe_key IN (
-        SELECT dedupe_key
-        FROM seen_sessions
-        ORDER BY seen_at DESC, dedupe_key DESC
-        LIMIT -1 OFFSET ?
-      )
-    `,
-    args: [maxSeenSessions]
-  });
+function extractTextFromAssistantMessage(message) {
+  return extractTextFromRoleMessage(message, "assistant", " ");
 }
-function shouldSkipSession(sessionKey) {
-  return SKIP_SESSION_PATTERNS.some((pattern) => sessionKey.includes(pattern));
+function truncateMessageText(text, maxChars = EXCHANGE_TEXT_MAX_CHARS) {
+  return text.length > maxChars ? text.slice(0, maxChars) : text;
 }
-async function hasSeenSession(sessionKey, db) {
-  let seen = seenSessions.has(sessionKey);
-  if (seen) {
-    touchSeenSessionCache(sessionKey);
-    sessionStartLog.debug(
-      `hasSeenSession key=${sessionKey.slice(0, 12)} found=${seen} mapSize=${seenSessions.size}`
-    );
-    return true;
+function stripPromptMetadata(raw) {
+  if (!raw) {
+    return "";
   }
-  if (canExecuteSql(db)) {
-    try {
-      seen = await hasSeenSessionInDb(db, sessionKey);
-      if (seen) {
-        touchSeenSessionCache(sessionKey);
-      }
-    } catch (err) {
-      sessionStartLog.warn(`hasSeenSession db lookup failed: ${toErrorMessage(err)}`);
+  try {
+    const pattern = /\[\w{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2} (?:[A-Z]{2,5}|GMT[+-]\d{1,2})\] /g;
+    let lastMatchEnd = -1;
+    let match = null;
+    while ((match = pattern.exec(raw)) !== null) {
+      lastMatchEnd = match.index + match[0].length;
     }
+    if (lastMatchEnd >= 0) {
+      return raw.slice(lastMatchEnd).trim();
+    }
+    return raw.trim();
+  } catch {
+    return "";
   }
-  sessionStartLog.debug(
-    `hasSeenSession key=${sessionKey.slice(0, 12)} found=${seen} mapSize=${seenSessions.size}`
-  );
-  return seen;
 }
-async function markSessionSeen(sessionKey, db) {
-  touchSeenSessionCache(sessionKey);
-  if (!canExecuteSql(db)) {
-    return;
-  }
-  const nowMs = Date.now();
+function extractLastExchangeText(messages, maxTurns = EXCHANGE_USER_TURN_LIMIT) {
   try {
-    await db.execute({
-      sql: "INSERT OR REPLACE INTO seen_sessions (dedupe_key, seen_at) VALUES (?, ?)",
-      args: [sessionKey, nowMs]
-    });
-    if (nowMs - sessionStateGlobals.lastCleanupMs > CLEANUP_INTERVAL_MS) {
-      await cleanupSeenSessionsInDb(db, nowMs);
-      sessionStateGlobals.lastCleanupMs = nowMs;
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return "";
     }
-  } catch (err) {
-    sessionStartLog.warn(`markSessionSeen db write failed: ${toErrorMessage(err)}`);
+    if (maxTurns <= 0) {
+      return "";
+    }
+    const collected = [];
+    let collectedUserTurns = 0;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const message = messages[index];
+      const userText = sanitizeTranscriptTurnText(extractTextFromUserMessage(message));
+      if (userText) {
+        collected.push({
+          role: "user",
+          text: truncateMessageText(userText.replace(/\s+/g, " ").trim())
+        });
+        collectedUserTurns += 1;
+        if (collectedUserTurns >= maxTurns) {
+          break;
+        }
+        continue;
+      }
+      const assistantText = sanitizeTranscriptTurnText(extractTextFromAssistantMessage(message));
+      if (assistantText) {
+        collected.push({
+          role: "assistant",
+          text: truncateMessageText(assistantText.replace(/\s+/g, " ").trim())
+        });
+      }
+    }
+    if (collected.length === 0) {
+      return "";
+    }
+    return collected.reverse().map((turn) => `${turn.role === "user" ? "U" : "A"}: ${turn.text}`).join(" | ");
+  } catch {
+    return "";
   }
 }
-function resolveMidSessionLimit(raw, fallback) {
-  if (typeof raw !== "number" || !Number.isFinite(raw)) {
-    return fallback;
-  }
-  const normalized = Math.trunc(raw);
-  if (normalized <= 0) {
-    return fallback;
+async function listSessionFileCandidates(sessionsDir, currentSessionId, logger) {
+  try {
+    const normalizedSessionId = currentSessionId?.trim();
+    const entries = await readdir(sessionsDir, { withFileTypes: true });
+    const candidatePaths = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+      const isPlainJsonl = entry.name.endsWith(".jsonl");
+      const isTranscriptArtifact = SESSION_TRANSCRIPT_ARTIFACT_MARKERS.some((marker) => entry.name.includes(marker));
+      if (!isPlainJsonl && !isTranscriptArtifact) {
+        continue;
+      }
+      if (entry.name.includes(".deleted.") && !entry.name.includes(".jsonl.deleted.")) {
+        continue;
+      }
+      if (normalizedSessionId && entry.name.startsWith(normalizedSessionId)) {
+        continue;
+      }
+      candidatePaths.push(path10.join(sessionsDir, entry.name));
+    }
+    if (candidatePaths.length === 0) {
+      return [];
+    }
+    const statResults = await Promise.all(
+      candidatePaths.map(async (filePath) => {
+        try {
+          const fileStats = await stat(filePath);
+          return { filePath, mtimeMs: fileStats.mtimeMs };
+        } catch {
+          return null;
+        }
+      })
+    );
+    const candidates = statResults.filter(
+      (result) => result !== null
+    );
+    if (candidates.length === 0) {
+      return [];
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates;
+  } catch (err) {
+    logger?.debug?.(
+      `listSessionFileCandidates: failed to read sessions dir "${sessionsDir}": ${toErrorMessage(err)}`
+    );
+    return [];
   }
-  return normalized;
 }
-function resolveMidSessionSimilarityThreshold(raw) {
-  if (typeof raw !== "number" || !Number.isFinite(raw)) {
-    return DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD;
-  }
-  if (raw < 0 || raw > 1) {
-    return DEFAULT_MID_SESSION_QUERY_SIMILARITY_THRESHOLD;
+async function extractRecentTurnObjects(filePath, maxTurns = DEFAULT_RECENT_TURN_LIMIT) {
+  try {
+    if (!filePath) {
+      return [];
+    }
+    const parsedMaxTurns = Number.isFinite(maxTurns) ? Math.max(0, Math.trunc(maxTurns)) : 0;
+    if (parsedMaxTurns === 0) {
+      return [];
+    }
+    const allTurns = [];
+    await new Promise((resolve, reject) => {
+      const rl = createInterface2({
+        input: createReadStream2(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity
+      });
+      rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          return;
+        }
+        let record;
+        try {
+          record = JSON.parse(trimmed);
+        } catch {
+          return;
+        }
+        if (!isRecord(record) || record["type"] !== "message") {
+          return;
+        }
+        const message = record["message"];
+        const messageTimestamp = isRecord(message) && typeof message["timestamp"] === "string" ? message["timestamp"] : void 0;
+        const timestamp2 = typeof record["timestamp"] === "string" ? record["timestamp"] : messageTimestamp;
+        const userText = extractTextFromRoleMessage(message, "user", "\n");
+        if (userText) {
+          allTurns.push({ role: "user", text: userText, timestamp: timestamp2 });
+          return;
+        }
+        const assistantText = extractTextFromRoleMessage(message, "assistant", "\n");
+        if (assistantText) {
+          allTurns.push({ role: "assistant", text: assistantText, timestamp: timestamp2 });
+        }
+      });
+      rl.on("close", resolve);
+      rl.on("error", reject);
+    });
+    const sanitizedTurns = sanitizeTranscriptTurns(allTurns, {
+      maxCharsPerTurn: RECENT_TURN_MAX_CHARS
+    });
+    return sanitizedTurns.slice(-parsedMaxTurns);
+  } catch {
+    return [];
   }
-  return raw;
-}
-function clearSessionState() {
-  seenSessions.clear();
-  sessionStateGlobals.lastCleanupMs = 0;
-  sessionSignalState.clear();
-  handoffSeenSessionIds.clear();
-  ledgerStore.ledgers.clear();
-  ledgerStore.aliases.clear();
-  sessionRef.current = "";
 }
 
 // src/modules/ingestion/application/extract-text.ts
@@ -29338,6 +29734,16 @@ function resolveWarn(pluginConfig) {
     log8.warn(message);
   };
 }
+function resolveLiveRecallWriteMetadata() {
+  const sessionId = sessionRef.current.trim();
+  if (!sessionId) {
+    return void 0;
+  }
+  return {
+    sessionId,
+    platform: "openclaw"
+  };
+}
 function buildStoreToolReceipt(decisions, fallbackCounts, warningCount) {
   const useDecisionCounts = decisions.length > 0;
   const countByAction = (action) => decisions.filter((decision) => decision.action === action).length;
@@ -29431,7 +29837,12 @@ async function runRecallTool(params, defaultProject, dbPath) {
       const recalledEntryIds = result.results.map((item) => item.entry?.id).filter((entryId) => typeof entryId === "string" && entryId.length > 0);
       if (recalledEntryIds.length > 0) {
         try {
-          enqueueRecallEventWrite(recalledEntryIds, /* @__PURE__ */ new Date(), void 0, dbPath);
+          enqueueRecallEventWrite(
+            recalledEntryIds,
+            /* @__PURE__ */ new Date(),
+            resolveLiveRecallWriteMetadata(),
+            dbPath
+          );
         } catch (error) {
           log8.warn(`failed to enqueue recall event write: ${toErrorMessage(error)}`);
         }