agenr 0.12.0 → 0.12.2

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [0.12.2] - 2026-03-22
+
+### Recall Scoping Fixes
+
+- **Wildcard project passthrough.** `project: "*"` no longer gets silently dropped to `undefined` during recall request building. The wildcard marker now flows through the full stack to `hasWildcardProjectOverride` in `prepareRecallInputs`, enabling true cross-project recall.
+- **Default project fallback for unscoped recall.** When an agent calls `agenr_recall` without an explicit `project`, the session's default project is now used as a `universal_first` hint — searching the default project first with null-project fallback. Previously, unscoped recall defaulted to null-project-only entries, silently returning near-empty results for project-heavy corpora.
+- **Wildcard default when no project context.** When neither an explicit project nor a session default is available, unscoped recall now defaults to wildcard (`*`) cross-project search instead of null-project-only.
+
+### Browse Recall
+
+- **Temporal proximity rebalancing.** Browse mode recall now prioritizes temporal proximity over importance with a diversity pass, better surfacing recent entries during temporal exploration.
+- **Removed default 1d since window.** Browse mode no longer applies a default 1-day `since` window, allowing full temporal exploration of the corpus.
+
+### Update & Retire Improvements
+
+- **Expiry changes via `agenr_update`.** The update tool now supports changing an entry's expiry tier (`core` → `permanent`, etc.) without retiring and re-creating it. Entry history (confirmations, recall count, created_at) is preserved.
+- **Subject selectors for update and retire.** Both `agenr_update` and `agenr_retire` now accept `subject` as an alternative to `entry_id`. Subject matching is case-insensitive exact match; when multiple entries share a subject, the most recent is targeted.
+- **Agent action replay.** Retire and update operations now support recall target hints for agent action replay workflows.
+
+### Maintenance
+
+- **Vector integrity detection.** New `vector-integrity` maintain task detects and repairs drift between the vector shadow table and the entries table.
+
+## [0.12.1] - 2026-03-21
+
+### Post-Ingest Quality Fixes
+
+- **Active-only FTS index.** FTS triggers and rebuild helpers now scope to active entries only (`retired = 0, superseded_by IS NULL`). Retired entries no longer occupy FTS slots or get reindexed during maintenance.
+- **Active-only vector index.** The `idx_entries_embedding_shadow` partial index now excludes retired entries. Vector `top_k` queries no longer waste slots on retired embeddings that get post-filtered. Rebuild and health-check paths updated to match.
+- **Schema regression test.** Fresh `init`/`reset` must create active-only trigger and index definitions — validated by new schema test.
+
+### Passthrough Dedup Fix
+
+- **Normalized content hash dedup.** Passthrough now checks active `norm_content_hash` before insert, catching exact duplicates that survived because the previous `contentHash` included `source.file`. Identical content from different tool calls is now correctly deduplicated.
+- **Within-batch norm-hash tracking.** Local batch dedup tracks both `contentHash` and `normContentHash`, preventing same-batch duplicates with different synthetic source files.
+- **Granular skip tracking.** `stats.skipped` now counts by skipped candidates rather than matched set size.
+
+### Store Guidance
+
+- **Future-session test.** Updated `agenr_store` tool description, Memory Doctrine (`system-context.ts`), and SKILL.md with concrete store/don't-store guidance. Agents are now instructed to apply the "future-session test" before storing: will a fresh session need this to act differently, or is this just logging what happened?
+- **Importance calibration.** Added "importance is not recency" guidance — shipping events are 5-6, recurring operational hazards are 7-8.
+
 ## [0.12.0] - 2026-03-20
 
 ### Ingestion Overhaul

package/README.md

@@ -162,7 +162,7 @@ agenr recall "package manager"
    tags: tooling, package-manager
 ```
 
-Recall supports date range queries (`--since 14d --until 7d`), temporal browse mode (`--browse --since 1d`), and around-date targeting (`--around 2026-02-15 --around-radius 14`) to rank entries by distance from a specific date.
+Recall supports date range queries (`--since 14d --until 7d`), temporal browse mode (`--browse --since 1d`), and around-date targeting (`--around 2026-02-15 --around-radius 14`) to rank entries primarily by distance from a specific date with importance used as a secondary tiebreaker.
 
 ### Cross-session Handoff
 
@@ -257,7 +257,7 @@ This exposes four MCP tools: `agenr_recall`, `agenr_extract`, `agenr_retire`, an
 | `agenr store [files...]` | Store entries with semantic dedup |
 | `agenr recall [query]` | Semantic + memory-aware recall. Use `--since`/`--until` for date ranges, `--around` for target-date ranking, `--browse` for temporal mode. |
 | `agenr retire [subject]` | Retire a stale entry (hidden, not deleted). Match by subject or `--id`. |
-| `agenr update --id <id> --importance <n>` | Update an entry in place. Currently supports importance only. |
+| `agenr update --id <id> [--importance <n>] [--expiry <level>]` | Update mutable entry metadata in place. Supports importance and expiry; pass at least one. |
 | `agenr watch [file]` | Live-watch files/directories, auto-extract knowledge |
 | `agenr watcher install` | Install background watch daemon (macOS launchd) |
 | `agenr watcher status` | Show daemon status (running/stopped, pid, watched file, recent logs) |

package/dist/agent-store-passthrough-defaults-M7BZ5U6A.js

@@ -0,0 +1,36 @@
+import {
+  computeMinhashSig,
+  computeNormContentHash,
+  findExistingContentHashes,
+  findExistingNormContentHashes,
+  hashEntrySourceContent,
+  insertEntry,
+  minhashSigToBuffer
+} from "./chunk-UNB2GHB2.js";
+import "./chunk-5645B45W.js";
+import "./chunk-QDW77NBA.js";
+import "./chunk-OZK32TEX.js";
+import "./chunk-6HTA55NQ.js";
+import {
+  composeEmbeddingText
+} from "./chunk-RVPPKW4P.js";
+import "./chunk-FIKYMSL6.js";
+import "./chunk-7VFBBJVV.js";
+import "./chunk-MLKGABMK.js";
+
+// src/runtime/agent-store-passthrough-defaults.ts
+function resolveAgentStorePassthroughDefaults() {
+  return {
+    computeMinhashSigFn: computeMinhashSig,
+    computeNormContentHashFn: computeNormContentHash,
+    minhashSigToBufferFn: minhashSigToBuffer,
+    hashEntrySourceContentFn: hashEntrySourceContent,
+    findExistingContentHashesFn: (db, hashes) => findExistingContentHashes(db, hashes),
+    findExistingNormContentHashesFn: (db, hashes) => findExistingNormContentHashes(db, hashes),
+    composeEmbeddingTextFn: composeEmbeddingText,
+    insertEntryFn: (db, entry, embedding, contentHash, normContentHash, minhashSig, config, options) => insertEntry(db, entry, embedding, contentHash, normContentHash, minhashSig, config, options)
+  };
+}
+export {
+  resolveAgentStorePassthroughDefaults
+};

package/dist/{bulk-store-defaults-DS5DDUSF.js → bulk-store-defaults-DDVYI3DG.js}

@@ -1,7 +1,7 @@
 import {
   resolveBulkStoreDefaults
-} from "./chunk-DSOV3M3M.js";
-import "./chunk-Y4RTK5NN.js";
+} from "./chunk-BR65GBJG.js";
+import "./chunk-UNB2GHB2.js";
 import "./chunk-5645B45W.js";
 import "./chunk-QDW77NBA.js";
 import "./chunk-OZK32TEX.js";

package/dist/{chunk-DSOV3M3M.js → chunk-BR65GBJG.js}

@@ -5,7 +5,7 @@ import {
   hashEntrySourceContent,
   insertEntry,
   minhashSigToBuffer
-} from "./chunk-Y4RTK5NN.js";
+} from "./chunk-UNB2GHB2.js";
 import {
   composeEmbeddingText
 } from "./chunk-RVPPKW4P.js";

package/dist/chunk-CUCVRI3K.js

@@ -0,0 +1,34 @@
+// src/domain/watcher-demotion.ts
+var WATCHER_DEMOTED_TAG = "watcher-demoted";
+var DEFAULT_OPENCLAW_WATCHER_DEMOTION_IMPORTANCE_CAP = 4;
+var DEFAULT_OPENCLAW_WATCHER_DEMOTION_TTL_DAYS = 30;
+function clampInteger(value, floor, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(floor, Math.floor(value));
+}
+function resolveOpenClawWatcherDemotionConfig(config) {
+  const watcherConfig = config?.watcher?.openclawDemotion;
+  return {
+    enabled: watcherConfig?.enabled !== false,
+    importanceCap: Math.min(
+      10,
+      clampInteger(
+        watcherConfig?.importanceCap,
+        1,
+        DEFAULT_OPENCLAW_WATCHER_DEMOTION_IMPORTANCE_CAP
+      )
+    ),
+    ttlDays: clampInteger(
+      watcherConfig?.ttlDays,
+      1,
+      DEFAULT_OPENCLAW_WATCHER_DEMOTION_TTL_DAYS
+    )
+  };
+}
+
+export {
+  WATCHER_DEMOTED_TAG,
+  resolveOpenClawWatcherDemotionConfig
+};

package/dist/{chunk-W6MVPK2E.js → chunk-D3DYUJKW.js}

@@ -29,7 +29,7 @@ import {
   recordEntrySupport,
   resolveEmbeddingForText,
   updateEntryForMerge
-} from "./chunk-Y4RTK5NN.js";
+} from "./chunk-UNB2GHB2.js";
 import {
   applyEntryClassification,
   inferProjectFromTags,
@@ -47,7 +47,7 @@ import {
   createAppRuntime,
   readAppDbSession,
   resolveDefaultAppRuntimeDeps
-} from "./chunk-7IU43M5Q.js";
+} from "./chunk-YFOFO2FC.js";
 import {
   mapStoredEntry,
   shapeRecallText
@@ -65,7 +65,7 @@ import {
 import {
   createLogger,
   walCheckpoint
-} from "./chunk-UBX652ZM.js";
+} from "./chunk-HMBONTF3.js";
 import {
   DEFAULT_TASK_MODEL,
   resolveClaimExtractionBatchSize,
@@ -219,11 +219,11 @@ async function runSimpleStream(params) {
       continue;
     }
     if (event.type === "thinking_start") {
-      logVerbose(params, "[thinking]");
+      continue;
     } else if (event.type === "thinking_delta") {
       params.onStreamDelta?.(event.delta, "thinking");
     } else if (event.type === "thinking_end") {
-      logVerbose(params, "[/thinking]");
+      continue;
     } else if (event.type === "text_delta") {
       params.onStreamDelta?.(event.delta, "text");
     } else if (event.type === "toolcall_delta") {
@@ -948,6 +948,37 @@ async function buildEntityRegistry(db) {
   return buildEntityRegistryFromRows(rows);
 }
 
+// src/utils/expiry.ts
+var EXPIRY_SET = new Set(EXPIRY_LEVELS);
+var EXPIRY_PRIORITY = {
+  temporary: 0,
+  permanent: 1,
+  core: 2
+};
+function normalizeExpiry(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  return EXPIRY_SET.has(normalized) ? normalized : void 0;
+}
+function coerceExpiry(value, fallback = "temporary") {
+  return normalizeExpiry(value) ?? fallback;
+}
+function resolveHigherExpiry(a, b) {
+  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
+}
+function resolveHighestExpiry(expiries) {
+  let highest = "temporary";
+  for (const expiry of expiries) {
+    highest = resolveHigherExpiry(highest, expiry);
+  }
+  return highest;
+}
+
 // src/db/lockfile.ts
 import fs from "fs";
 import os from "os";
@@ -2301,37 +2332,6 @@ function evaluateConflictsForRejection(conflicts, newEntry, config) {
   };
 }
 
-// src/utils/expiry.ts
-var EXPIRY_SET = new Set(EXPIRY_LEVELS);
-var EXPIRY_PRIORITY = {
-  temporary: 0,
-  permanent: 1,
-  core: 2
-};
-function normalizeExpiry(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) {
-    return void 0;
-  }
-  return EXPIRY_SET.has(normalized) ? normalized : void 0;
-}
-function coerceExpiry(value, fallback = "temporary") {
-  return normalizeExpiry(value) ?? fallback;
-}
-function resolveHigherExpiry(a, b) {
-  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
-}
-function resolveHighestExpiry(expiries) {
-  let highest = "temporary";
-  for (const expiry of expiries) {
-    highest = resolveHigherExpiry(highest, expiry);
-  }
-  return highest;
-}
-
 // src/memory/store/mutations.ts
 async function applyEntryMutation(repository, processed, embedFn, apiKey, cache, config, options) {
   const mutation = processed.mutation;
@@ -5598,6 +5598,47 @@ async function finalizeRecallResults(params) {
   return results;
 }
 
+// src/domain/recall/browse-selection.ts
+var DEFAULT_BROWSE_DIVERSITY_TARGET = 4;
+function normalizeEntryType(result) {
+  const rawType = result.entry.type;
+  return typeof rawType === "string" ? rawType.trim().toLowerCase() : "";
+}
+function diversifyBrowseResults(results, limit, diversityTarget = DEFAULT_BROWSE_DIVERSITY_TARGET) {
+  const normalizedLimit = Math.max(0, Math.floor(limit));
+  if (normalizedLimit === 0 || results.length === 0) {
+    return [];
+  }
+  const normalizedDiversityTarget = Math.max(0, Math.floor(diversityTarget));
+  const seedTarget = Math.min(normalizedLimit, normalizedDiversityTarget);
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const admittedTypes = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (selected.length >= seedTarget) {
+      break;
+    }
+    const normalizedType = normalizeEntryType(result);
+    if (!normalizedType || admittedTypes.has(normalizedType)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+    admittedTypes.add(normalizedType);
+  }
+  for (const result of results) {
+    if (selected.length >= normalizedLimit) {
+      break;
+    }
+    if (selectedIds.has(result.entry.id)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+  }
+  return selected;
+}
+
 // src/domain/recall/lexical.ts
 var STOP_TOKENS = /* @__PURE__ */ new Set([
   "a",
@@ -5754,6 +5795,8 @@ var DEFAULT_RECALL_SATURATION = 10;
 var DEFAULT_WARM_START_THRESHOLD = 3;
 var DEFAULT_SYNTHETIC_FLOOR = 0.1;
 var DEFAULT_AGENT_SOURCE_BONUS = 0.05;
+var BROWSE_RECENCY_WEIGHT = 0.8;
+var BROWSE_IMPORTANCE_WEIGHT = 0.2;
 var MISSING_RECALL_DAYS = 99999;
 var EMPTY_RECALL_METRICS = {
   totalCount: 0,
@@ -5878,7 +5921,9 @@ function browseRecencyFactor(entry, now, aroundDate, aroundRadius = DEFAULT_AROU
   return resolveRecallRecency(entry, now, aroundDate, aroundRadius);
 }
 function scoreBrowseEntry(entry, now, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS) {
-  return clamp01((browseRecencyFactor(entry, now, aroundDate, aroundRadius) + importanceScore(entry.importance)) / 2);
+  const recency2 = browseRecencyFactor(entry, now, aroundDate, aroundRadius);
+  const importance = importanceScore(entry.importance);
+  return clamp01(recency2 * BROWSE_RECENCY_WEIGHT + importance * BROWSE_IMPORTANCE_WEIGHT);
 }
 function scoreSessionEntry(entry, effectiveNow, freshnessNow, metricsMap, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS, config) {
   return scoreEntryWithBreakdown(
@@ -6261,8 +6306,21 @@ async function fetchBrowseCandidates(params) {
     whereClauses.push("platform = ?");
     args.push(params.query.platform);
   }
-  args.push(params.limit);
   const whereClause = whereClauses.length > 0 ? "WHERE " + whereClauses.join(" AND ") : "";
+  const orderBy = params.aroundDate ? `
+      ORDER BY
+        ABS(julianday(created_at) - julianday(?)) ASC,
+        importance DESC,
+        created_at DESC
+    ` : `
+      ORDER BY
+        created_at DESC,
+        importance DESC
+    `;
+  if (params.aroundDate) {
+    args.push(params.aroundDate.toISOString());
+  }
+  args.push(params.limit);
   const result = await params.db.execute({
     sql: `
       SELECT
@@ -6270,10 +6328,10 @@ async function fetchBrowseCandidates(params) {
       FROM entries
       ${whereClause}
       -- SQL pre-sort is a best-effort approximation only.
-      -- Final order is determined by scoreBrowseEntry() (importance * recency decay)
-      -- which re-sorts post-fetch. The over-fetch buffer (limit*3, min 50)
+      -- Final order is determined by recency-first browse scoring and a post-score
+      -- diversity pass. The over-fetch buffer (limit*3, min 50)
       -- ensures the final top-N are present in the candidate pool.
-      ORDER BY importance DESC, created_at DESC
+      ${orderBy}
       LIMIT ?
     `,
     args
@@ -6499,6 +6557,7 @@ async function recallBrowseMode(params) {
     query: browseQuery,
     limit: browseLimit,
     now: params.now,
+    aroundDate: params.prepared.temporal.aroundDate,
     projectFilter: params.prepared.scope.resolution.primaryFilter
   });
   const filtered = browseCandidates.filter(
@@ -6519,7 +6578,11 @@ async function recallBrowseMode(params) {
     aroundRadiusDays: params.prepared.temporal.aroundRadiusDays
   });
   scored.sort((left, right) => right.score - left.score);
-  return scored.slice(0, requestedLimit);
+  const results = diversifyBrowseResults(scored, requestedLimit, DEFAULT_BROWSE_DIVERSITY_TARGET);
+  if (params.trace) {
+    params.trace.finalResultIds = results.map((result) => result.entry.subject ?? result.entry.id);
+  }
+  return results;
 }
 async function retrieveCandidates(params) {
   if (!params.prepared.retrievalSearchText) {
@@ -6924,11 +6987,12 @@ function resolvePreparedRecallScope(query, normalizedQuery) {
   const explicitWildcardProject = hasWildcardProjectOverride(query.project);
   const explicitProjects = explicitWildcardProject ? [] : parseProjectList(query.project);
   const explicitExcludedProjects = parseProjectList(query.excludeProject);
-  const inferredProjectHints = deriveRecallProjectScopeHints({
+  const inferredProjectHints = explicitWildcardProject ? [] : deriveRecallProjectScopeHints({
     queryText: normalizedQuery?.searchText ?? query.text ?? "",
     explicitProjects
   });
-  const projectHints = explicitProjects.length > 0 ? explicitProjects : inferredProjectHints;
+  const callerProjectHints = explicitProjects.length > 0 || explicitWildcardProject ? [] : parseProjectList(query.projectHints).filter((projectHint) => projectHint !== "*");
+  const projectHints = explicitProjects.length > 0 ? explicitProjects : Array.from(/* @__PURE__ */ new Set([...inferredProjectHints, ...callerProjectHints]));
   const intent = projectHints.length > 0 ? "project" : normalizedQuery?.scopeIntent ?? "ambiguous";
   if (query.universalOnly === true) {
     return {