agenr 0.13.4 → 0.14.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [0.14.1] - 2026-03-24
+
+### Surgeon Health Fixes (001–006)
+
+Six targeted fixes based on a traced production surgeon run investigation:
+
+- **Temporary entry TTL enforcement.** Temporary entries with low importance and zero recalls auto-expire after a configurable window (default 21 days). Rebuild-aware — entries are protected after a corpus rebuild until they've had time to be recalled. Short-lived entries are excluded from merge clustering.
+- **Co-recall / co-ingest split.** The co-recall edge graph now distinguishes real co-recall (entries recalled together in a session) from co-ingest (entries from the same source file). Legacy edges retyped to `co_ingested`. Quality evolution only reads `co_recalled` edges. Live recall events now carry `session_id`.
+- **Quality scoring recalibration.** Replaced the quality evolution formula with a rebuild-aware, type-aware, positive-signal-only design. Grace periods per entry type (preferences 14d, decisions 60d, etc.) prevent new entries from collapsing to floor scores. Quality only goes up from evidence. Gentle importance-dampened decay for unrecalled entries. Centralized quality tier thresholds. Removed dead seed path.
+- **Two-tier health forgetting metric.** Health stats now report both an actionable cleanup pool (what the surgeon would evaluate) and a mechanical auto-retire count (ultra-conservative threshold). Removed dead `lowScoreTriggerCount` config.
+- **Generic subject key suppression.** Contradiction scanning and clustering now detect and suppress generic `entity/type` subject keys (e.g., `jim/decision`) that collapse unrelated entries into false-positive pairs.
+- **Semantic cluster precision.** Type-aware similarity thresholds for dedup clustering — decisions and lessons require 0.75, events 0.72, facts and preferences 0.60. Prevents thematic neighborhoods from being clustered as duplicates. Type-aware diameter floor in post-union validation.
+
+### Other
+
+- **`db vector-check` command.** New CLI command for diagnosing vector index health.
+
+## [0.14.0] - 2026-03-24
+
+### Surgeon — Budget Model Overhaul
+
+- **`--budget` now means dollars, not tokens.** The cumulative token budget that double-counted context re-sends across turns is gone. The surgeon is now constrained by two things: cost (dollars) and context window (tokens). Config `surgeon.budget` is dollars per run. Default: $5.
+- **Context-aware limits.** New `surgeon.contextLimit` config field and `--context-limit` CLI flag. Auto-detects from `model.contextWindow * 0.85` if not set. The surgeon stops when context is full, not from artificial token counting.
+- **`costCap` removed.** Replaced by `budget`. Old `costCap` values are accepted as backward-compatible alias with deprecation warning.
+
+### Surgeon — Contradiction Improvements
+
+- **`coexists` relation for `log_conflict`.** The surgeon can now log reviewed false-positive pairs as coexisting rather than forcing them into `contradicts` or `supersedes`. Coexists conflicts are auto-resolved as `keep-both` so they don't accumulate as pending conflicts and future scans skip them.
+- **Improved contradiction candidate filtering.** Suppresses historical series pairs (release versions, prompt paths, roadmap snapshots) from claim divergence scanning. Prioritizes `current_state` claim divergence pairs.
+
+### Surgeon — Retirement Candidate Scoping
+
+- **Scoped candidate queries.** `query_candidates` now accepts `scope` parameter: `actionable` (default) filters to entries with high retirement probability — temporary, ephemeral, todos, low-importance events, mislabeled temporal artifacts. `all` shows the full candidate pool for deep sweeps.
+- **Improved candidate ordering.** Actionable scope returns temporary entries first, then ephemeral, then todos, then low-importance events. Durable permanent decisions and preferences are excluded from the default scope.
+- **Two-phase retirement in auto mode.** Surgeon starts with actionable candidates, widens to full pool only if budget remains after exhausting the actionable set.
+
 ## [0.13.4] - 2026-03-23
 
 ### Surgeon

package/README.md

@@ -34,7 +34,7 @@ That's it. The interactive wizard handles everything: auth setup, platform detec
 - **Extract** - An LLM reads your transcripts and pulls out structured entries. Smart filtering removes noise (tool calls, file contents, boilerplate - about 80% of a typical session) before the LLM sees it. Hedged or unverified agent claims are capped at importance 5 with an `unverified` tag.
 - **Store** - Entries get embedded and compared against existing knowledge. Near-duplicates reinforce existing entries. New information gets inserted. Online dedup catches copies in real-time.
 - **Recall** - Semantic search plus memory-aware ranking. Entries you recall often score higher. Stale entries decay. Contradicted entries get penalized.
-- **Surgeon** - Corpus health maintenance: deterministic cleanup, quality evolution, vector integrity checks, and LLM-assisted retirement, dedup, and contradiction resolution.
+- **Surgeon** - Corpus health maintenance: deterministic cleanup, quality evolution, and LLM-assisted retirement, dedup, and contradiction resolution.
 
 ```text
 Transcript -> Filter -> Extract -> Store -> Recall
@@ -262,13 +262,13 @@ This exposes five MCP tools: `agenr_recall`, `agenr_store`, `agenr_extract`, `ag
 | `agenr watcher install` | Install background watch daemon (macOS launchd) |
 | `agenr watcher status` | Show daemon status (running/stopped, pid, watched file, recent logs) |
 | `agenr watcher logs` | Stream or show recent daemon logs |
-| `agenr surgeon run` | Run corpus-health maintenance: cleanup, quality evolution, vector checks, and retirement/dedup/contradictions |
+| `agenr surgeon run` | Run corpus-health maintenance: cleanup, quality evolution, and retirement/dedup/contradictions |
 | `agenr benchmark` | Run extraction against benchmark fixtures and score results |
 | `agenr context` | Generate context file for AI tool integration |
-| `agenr health` | Show database health and forgetting candidates |
+| `agenr health` | Show database health and cleanup status |
 | `agenr mcp` | Start MCP server (stdio) |
 | `agenr todo <subcommand>` | Manage todos in the knowledge base |
-| `agenr db <cmd>` | Database management (stats, version, export, reset, path, check, rebuild-index) |
+| `agenr db <cmd>` | Database management (stats, version, export, reset, path, check, vector-check, rebuild-index) |
 
 Full reference: [docs/CLI.md](./docs/CLI.md) | [docs/CONFIGURATION.md](./docs/CONFIGURATION.md)
 
@@ -306,7 +306,7 @@ For the product thesis, see [docs/vision.md](./docs/vision.md).
 | Plugin install fails during wizard | Run `openclaw plugins install agenr` manually, then `openclaw gateway restart` |
 | Embeddings fail | Set `OPENAI_API_KEY` env var or `agenr config set-key openai <key>` |
 | Database locked | Wait for the active write-heavy command to finish (`agenr ingest --bulk`, `agenr surgeon run --apply`, etc.) and retry |
-| Recall returns nothing after force-kill | `agenr db rebuild-index` (vector index corruption) |
+| Recall returns nothing after force-kill | `agenr db vector-check --rebuild` (vector shadow-table drift) |
 | Extraction fails mid-file | Retry - dedup skips already-stored entries |
 | Stale handoff entries persist | Run `agenr recall --browse --since 1d` to check, then `agenr retire --id <id>` |
 | Gateway doesn't pick up plugin | Run `openclaw gateway restart` after plugin install |

package/dist/{chunk-WB6OH7LM.js → chunk-2JI5DOZ2.js}

@@ -1,3 +1,7 @@
+import {
+  toNumber,
+  toStringValue
+} from "./chunk-QDGOYFN7.js";
 import {
   authMethodToProvider,
   normalizeProvider,
@@ -5,7 +9,7 @@ import {
   resolveModel,
   resolveModelForTask,
   resolveUserPath
-} from "./chunk-QI23WU2O.js";
+} from "./chunk-SJN63MTD.js";
 import {
   toErrorMessage
 } from "./chunk-UUUFPTSM.js";
@@ -15,6 +19,42 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/shared/domain/types.ts
+var KNOWLEDGE_TYPES = [
+  "fact",
+  "decision",
+  "preference",
+  "todo",
+  "relationship",
+  "event",
+  "lesson",
+  "reflection"
+];
+var ENTRY_TYPES = KNOWLEDGE_TYPES;
+var IMPORTANCE_MIN = 1;
+var IMPORTANCE_MAX = 10;
+var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+var SCOPE_LEVELS = ["private", "personal", "public"];
+var KNOWLEDGE_PLATFORMS = ["openclaw", "claude-code", "codex", "plaud"];
+var ENTRY_KINDS = ["directive", "state", "identity", "episode", "reference"];
+var TEMPORAL_CLASSES = ["ephemeral", "durable"];
+var REJECTED_CONFLICT_ENTRY_ID = "rejected";
+
+// src/shared/domain/subject-key.ts
+var ENTRY_TYPE_ATTRIBUTES = new Set(KNOWLEDGE_TYPES);
+function isGenericSubjectKey(subjectKey, entryType) {
+  const normalizedSubjectKey = subjectKey?.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;
+}
+
 // src/modules/store/domain/structured-claim.ts
 var STRUCTURED_CLAIM_IDENTITY_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "decision"]);
 var STRUCTURED_CLAIM_CONFIDENCE_FLOOR = 0.8;
@@ -109,6 +149,48 @@ var TRANSITION_MULTI_STEP_MARKERS = [
   /\bafter that\b/i,
   /\bthen\b.{0,24}\b(?:move|moved|switch|switched|replace|replaced|migrate|migrated|transition|transitioned)\b/i
 ];
+var 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"
+]);
+var TOPIC_SLUG_MAX_TOKENS = 6;
+var TOPIC_SLUG_MAX_LENGTH = 60;
+var TOPIC_SLUG_MIN_LENGTH = 3;
 function normalizeLower(value) {
   return value?.trim().toLowerCase() ?? "";
 }
@@ -325,6 +407,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 subjectKey = buildSubjectKey(subjectEntity, subjectAttribute, fallbackSubjectKey);
+  if (!isGenericSubjectKey(subjectKey, entry.type)) {
+    return subjectAttribute;
+  }
+  return deriveTopicAttribute(entry, subjectAttribute);
+}
 function normalizeStructuredClaimFields(entry) {
   const normalizedSubjectEntity = normalizeLower(entry.subjectEntity);
   const normalizedSubjectKey = normalizeLower(entry.subjectKey);
@@ -341,6 +451,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,
@@ -349,11 +469,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;
@@ -1382,7 +1502,7 @@ var SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL = `
 `;
 var TEMP_REPAIR_TABLE = "_vec_repair";
 var REPAIR_CHUNK_SIZE = 100;
-function toNumber(value) {
+function toNumber2(value) {
   if (typeof value === "number") {
     return value;
   }
@@ -1395,14 +1515,14 @@ function toNumber(value) {
   return Number.NaN;
 }
 function toFiniteCount(value) {
-  const numeric = toNumber(value);
+  const numeric = toNumber2(value);
   if (!Number.isFinite(numeric)) {
     return 0;
   }
   return Math.max(0, Math.trunc(numeric));
 }
 function normalizeRowid(value) {
-  const numeric = toNumber(value);
+  const numeric = toNumber2(value);
   if (!Number.isFinite(numeric)) {
     return null;
   }
@@ -1416,6 +1536,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");
@@ -1508,6 +1631,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);
@@ -1645,6 +1780,221 @@ async function getBulkIngestMeta(db) {
   }
 }
 
+// src/shared/infrastructure/db/co-recall.ts
+var DEFAULT_EDGE_INCREMENT = 0.1;
+var MAX_USED_ENTRIES = 20;
+var CO_RECALL_EDGE_TYPE = "co_recalled";
+var CO_INGEST_EDGE_TYPE = "co_ingested";
+var ALL_EDGE_TYPES = [CO_RECALL_EDGE_TYPE, CO_INGEST_EDGE_TYPE];
+var ALL_EDGE_TYPES_PLACEHOLDERS = ALL_EDGE_TYPES.map(() => "?").join(", ");
+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 strengthenCoIngestEdges(db, usedEntryIds, timestamp2) {
+  await strengthenEdges(db, usedEntryIds, timestamp2, CO_INGEST_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: toNumber(row.weight),
+    sessionCount: toNumber(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, toNumber(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: toNumber(row.weight),
+    sessionCount: toNumber(row.session_count),
+    lastCoRecalled: toStringValue(row.last_co_recalled)
+  }));
+}
+
+// src/shared/infrastructure/db/meta.ts
+var LAST_CORPUS_REBUILD_AT_META_KEY = "last_corpus_rebuild_at";
+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);
+}
+
 // src/shared/infrastructure/db/migrations/reflection-importance-cap.ts
 var REFLECTION_IMPORTANCE_CAP_META_KEY = "reflection_importance_cap_v1";
 async function applyReflectionImportanceCapMigration(db) {
@@ -2014,6 +2364,7 @@ async function migrateRecallEvents(db) {
 
 // src/shared/infrastructure/db/schema/init.ts
 var LEGACY_IMPORTANCE_BACKFILL_META_KEY = "legacy_importance_backfill_from_confidence_v1";
+var CO_INGEST_EDGE_RETYPE_META_KEY = "co_recall_edges_retyped_to_co_ingested_v1";
 function readColumnNames(rows) {
   return new Set(rows.map((row) => String(row.name ?? "")));
 }
@@ -2134,6 +2485,36 @@ async function backfillLegacyImportanceFromConfidence(client) {
   } catch {
   }
 }
+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: `
+      UPDATE co_recall_edges
+      SET edge_type = ?
+      WHERE edge_type = ?
+    `,
+    args: [CO_INGEST_EDGE_TYPE, CO_RECALL_EDGE_TYPE]
+  });
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES (?, datetime('now'), datetime('now'))
+      ON CONFLICT(key) DO NOTHING
+    `,
+    args: [CO_INGEST_EDGE_RETYPE_META_KEY]
+  });
+}
 async function stampSchemaMetadata(client) {
   await client.execute({
     sql: `
@@ -2190,11 +2571,13 @@ 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);
 }
 
 // src/shared/infrastructure/db/schema/reset.ts
@@ -2940,6 +3323,17 @@ function resolveDefaultAppRuntimeDeps() {
 }
 
 export {
+  KNOWLEDGE_TYPES,
+  ENTRY_TYPES,
+  IMPORTANCE_MIN,
+  IMPORTANCE_MAX,
+  EXPIRY_LEVELS,
+  SCOPE_LEVELS,
+  KNOWLEDGE_PLATFORMS,
+  ENTRY_KINDS,
+  TEMPORAL_CLASSES,
+  REJECTED_CONFLICT_ENTRY_ID,
+  isGenericSubjectKey,
   STRUCTURED_CLAIM_IDENTITY_TYPES,
   STATE_ANCHOR_PREDICATE,
   STATE_TRANSITION_PREDICATE,
@@ -2958,13 +3352,23 @@ export {
   createLogger,
   OPENCLAW_PLUGIN_SCHEMA_STATEMENTS,
   OPENCLAW_PLUGIN_COLUMN_MIGRATIONS,
-  getVectorIndexShadowStats,
+  checkVectorIntegrity,
   rebuildVectorIndex,
   dropFtsTriggersAndIndex,
   rebuildFtsAndTriggers,
   rebuildVectorIndex2,
   setBulkIngestMeta,
   clearBulkIngestMeta,
+  MAX_USED_ENTRIES,
+  CO_RECALL_EDGE_TYPE,
+  CO_INGEST_EDGE_TYPE,
+  strengthenCoRecallEdges,
+  strengthenCoIngestEdges,
+  getCoRecallNeighbors,
+  getCoRecallEdgeCounts,
+  getTopCoRecallEdges,
+  getLastCorpusRebuildAt,
+  setLastCorpusRebuildAt,
   resetDb,
   DEFAULT_DB_PATH,
   buildBackupPath,

package/dist/{chunk-EAIHUY6F.js → chunk-4JHTJXYY.js}

@@ -4,7 +4,7 @@ import {
   getPendingReviews,
   rehabilitateEntry,
   resolveReview
-} from "./chunk-BIND34BY.js";
+} from "./chunk-LLHGEYS7.js";
 import {
   classifyStructuredConflictPair,
   deleteCoRecallEdgesForEntryIds,
@@ -12,24 +12,23 @@ import {
   getConflictStats,
   resolveConflictLog,
   retireEntries
-} from "./chunk-NGV264GF.js";
-import {
-  getCoRecallNeighbors,
-  getTopCoRecallEdges
-} from "./chunk-GOV2RGHZ.js";
+} from "./chunk-FUOKOMSN.js";
 import {
   DEFAULT_DB_PATH,
   backupDb,
   buildBackupPath,
+  checkVectorIntegrity,
   closeDb,
   createLogger,
+  getCoRecallNeighbors,
   getDb,
+  getTopCoRecallEdges,
   initDb,
   rebuildVectorIndex,
   resetDb,
   resolveDefaultAppRuntimeDeps,
   walCheckpoint
-} from "./chunk-WB6OH7LM.js";
+} from "./chunk-2JI5DOZ2.js";
 import {
   toNumber,
   toStringValue
@@ -37,7 +36,7 @@ import {
 import {
   readConfig,
   resolveConfigDir
-} from "./chunk-QI23WU2O.js";
+} from "./chunk-SJN63MTD.js";
 
 // src/runtime/operations.ts
 import fs from "fs/promises";
@@ -525,6 +524,7 @@ function resolveDbCommandDefaults() {
     initDb: shared.initDbFn,
     closeDb: shared.closeDbFn,
     backupDb,
+    checkVectorIntegrity,
     getConflictShadowSummary,
     resetDb,
     walCheckpoint,

package/dist/{chunk-27X6QJCR.js → chunk-4QW3AAO2.js}

@@ -1,11 +1,11 @@
 import {
   resolveDbCommandDefaults
-} from "./chunk-EAIHUY6F.js";
+} from "./chunk-4JHTJXYY.js";
 import {
   resolveConfigDir,
   resolveDefaultKnowledgeDbPath,
   resolveUserPath
-} from "./chunk-QI23WU2O.js";
+} from "./chunk-SJN63MTD.js";
 
 // src/shared/operations/session-store-metrics/workflow.ts
 import fs from "fs/promises";