agenr 1.8.1 → 1.8.2

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [1.8.2] - 2026-04-12
+
+Temporal parsing and ingest workflow polish patch release.
+
+### Changed
+
+- **Relative time parsing now accepts small spelled-out amounts.** Episode temporal-window parsing now recognizes natural language queries such as "two days ago" for small relative ranges, improving recall routing for conversational phrasing.
+- **Local Cursor scaffolding stays out of repo status.** `.gitignore` now excludes local Cursor rules and skills directories so release work and day-to-day development stay focused on product changes.
+
+### Fixed
+
+- **Ingest progress propagation now reaches the CLI consistently.** The ingestion app and CLI layers now forward progress events end-to-end so long-running ingest runs surface stage updates reliably.
+
+### Validation
+
+Changes since last push to `origin/master`:
+
+- Update `.gitignore` to exclude cursor rules and skills directories
+- Enhance temporal parsing with small spelled-out relative amounts
+- Enhance ingestion process with progress event propagation
+
 ## [1.8.1] - 2026-04-11
 
 Ingest concurrency and progress reporting patch release.

package/dist/adapters/openclaw/index.js

@@ -7,7 +7,7 @@ import {
   parseTuiSessionKey,
   readOpenClawSessionsStore,
   storeEntriesDetailed
-} from "../../chunk-O45JQ6O3.js";
+} from "../../chunk-PVYS6BMG.js";
 import {
   EMBEDDING_DIMENSIONS,
   ENTRY_TYPES,
@@ -24,7 +24,7 @@ import {
   resolveEmbeddingModel,
   runUnifiedRecall,
   validateTemporalValidityRange
-} from "../../chunk-LVDQXSHP.js";
+} from "../../chunk-SQARNOYD.js";
 import {
   resolveClaimSlotPolicy
 } from "../../chunk-GUDCFFRV.js";

package/dist/{chunk-O45JQ6O3.js → chunk-PVYS6BMG.js}

@@ -22,7 +22,7 @@ import {
   readOptionalString,
   readRequiredString,
   validateTemporalValidityRange
-} from "./chunk-LVDQXSHP.js";
+} from "./chunk-SQARNOYD.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -2737,7 +2737,7 @@ async function extractClaimKeyDecision(entry, llm, config, options = {}) {
 async function getEntityHints(db) {
   return db.getDistinctClaimKeyPrefixes();
 }
-async function runBatchClaimExtraction(results, ports, config, concurrency = 10, onWarning, onDiagnostic) {
+async function runBatchClaimExtraction(results, ports, config, concurrency = 10, onWarning, onDiagnostic, onProgress) {
   if (!config.enabled) {
     return /* @__PURE__ */ new Map();
   }
@@ -2748,6 +2748,8 @@ async function runBatchClaimExtraction(results, ports, config, concurrency = 10,
   const retryEntries = [];
   const stageSize = normalizeClaimExtractionConcurrency(concurrency);
   const orderedEntries = results.flatMap((result) => result.entries);
+  const totalEligibleEntries = orderedEntries.filter((entry) => !entry.claim_key && config.eligibleTypes.includes(entry.type)).length;
+  let completedPrimaryEntries = 0;
   for (let stageStart = 0; stageStart < orderedEntries.length; stageStart += stageSize) {
     const stageEntries = orderedEntries.slice(stageStart, stageStart + stageSize);
     const stageRequests = [];
@@ -2774,11 +2776,22 @@ async function runBatchClaimExtraction(results, ports, config, concurrency = 10,
         hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
       });
     }
-    const stageDecisions = await Promise.all(
-      stageRequests.map(async ({ entry, hintSnapshot }) => ({
-        entry,
-        decision: await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning)
-      }))
+    const stageDecisions = await executeClaimExtractionStageRequests(
+      stageRequests,
+      llm,
+      config,
+      onWarning,
+      completedPrimaryEntries,
+      totalEligibleEntries,
+      (completedEntries, totalEntries) => {
+        completedPrimaryEntries = completedEntries;
+        onProgress?.({
+          phase: "primary",
+          completedEntries,
+          totalEntries,
+          totalEligibleEntries
+        });
+      }
     );
     for (const { entry, decision } of stageDecisions) {
       diagnostics.set(entry, decision.diagnostic);
@@ -2792,16 +2805,30 @@ async function runBatchClaimExtraction(results, ports, config, concurrency = 10,
     }
   }
   if (retryEntries.length > 0 && extractedEntries.size > 0) {
-    for (let stageStart = 0; stageStart < retryEntries.length; stageStart += stageSize) {
-      const stageRequests = retryEntries.slice(stageStart, stageStart + stageSize).filter((entry) => !entry.claim_key).map((entry) => ({
+    const retryEligibleEntries = retryEntries.filter((entry) => !entry.claim_key);
+    const totalRetryEntries = retryEligibleEntries.length;
+    let completedRetryEntries = 0;
+    for (let stageStart = 0; stageStart < retryEligibleEntries.length; stageStart += stageSize) {
+      const stageRequests = retryEligibleEntries.slice(stageStart, stageStart + stageSize).map((entry) => ({
         entry,
         hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
       }));
-      const stageDecisions = await Promise.all(
-        stageRequests.map(async ({ entry, hintSnapshot }) => ({
-          entry,
-          decision: await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning)
-        }))
+      const stageDecisions = await executeClaimExtractionStageRequests(
+        stageRequests,
+        llm,
+        config,
+        onWarning,
+        completedRetryEntries,
+        totalRetryEntries,
+        (completedEntries, totalEntries) => {
+          completedRetryEntries = completedEntries;
+          onProgress?.({
+            phase: "retry",
+            completedEntries,
+            totalEntries,
+            totalEligibleEntries
+          });
+        }
       );
       for (const { entry, decision } of stageDecisions) {
         diagnostics.set(entry, decision.diagnostic);
@@ -2824,6 +2851,20 @@ async function runBatchClaimExtraction(results, ports, config, concurrency = 10,
   }
   return extractedEntries;
 }
+async function executeClaimExtractionStageRequests(stageRequests, llm, config, onWarning, initialCompletedEntries, totalEntries, onProgress) {
+  let completedEntries = initialCompletedEntries;
+  return Promise.all(
+    stageRequests.map(async ({ entry, hintSnapshot }) => {
+      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning);
+      completedEntries += 1;
+      onProgress(completedEntries, totalEntries);
+      return {
+        entry,
+        decision
+      };
+    })
+  );
+}
 function normalizeClaimExtractionConcurrency(value) {
   if (!Number.isInteger(value) || value <= 0) {
     return 10;

package/dist/{chunk-LVDQXSHP.js → chunk-SQARNOYD.js}

@@ -4094,6 +4094,20 @@ function parseTimestamp(value) {
 // src/core/episode/temporal-window.ts
 var DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1e3;
 var DEFAULT_ANCHOR_RADIUS_DAYS = 3;
+var RELATIVE_NUMBER_WORDS = /* @__PURE__ */ new Map([
+  ["one", 1],
+  ["two", 2],
+  ["three", 3],
+  ["four", 4],
+  ["five", 5],
+  ["six", 6],
+  ["seven", 7],
+  ["eight", 8],
+  ["nine", 9],
+  ["ten", 10],
+  ["eleven", 11],
+  ["twelve", 12]
+]);
 var MONTH_INDEX = /* @__PURE__ */ new Map([
   ["january", 0],
   ["february", 1],
@@ -4243,9 +4257,9 @@ function parseTemporalWindow(text, now = /* @__PURE__ */ new Date()) {
       now: referenceNow
     });
   }
-  const relativeMatch = lower.match(/\b(\d+)\s+(day|days|week|weeks|month|months)\s+ago\b/);
+  const relativeMatch = lower.match(/\b(\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+(day|days|week|weeks|month|months)\s+ago\b/);
   if (relativeMatch?.[1] && relativeMatch[2]) {
-    const amount = Number(relativeMatch[1]);
+    const amount = parseRelativeAmount(relativeMatch[1]);
     if (Number.isFinite(amount) && amount > 0) {
       const unit = relativeMatch[2];
       if (unit.startsWith("day")) {
@@ -4446,6 +4460,12 @@ function buildLocalDateAtNoon(year, month, day) {
   }
   return parsed;
 }
+function parseRelativeAmount(value) {
+  if (/^\d+$/u.test(value)) {
+    return Number(value);
+  }
+  return RELATIVE_NUMBER_WORDS.get(value) ?? Number.NaN;
+}
 function resolveWeekStartDay() {
   try {
     const locale = Intl.DateTimeFormat().resolvedOptions().locale;

package/dist/cli.js

@@ -27,7 +27,7 @@ import {
   tokenizeGroundingText,
   validateEntriesWithIndexes,
   validateSupersessionRules
-} from "./chunk-O45JQ6O3.js";
+} from "./chunk-PVYS6BMG.js";
 import {
   DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
   DEFAULT_SURGEON_CONTEXT_LIMIT,
@@ -86,7 +86,7 @@ import {
   updateEntry,
   validateTemporalValidityRange,
   writeConfig
-} from "./chunk-LVDQXSHP.js";
+} from "./chunk-SQARNOYD.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -1104,10 +1104,23 @@ async function dedupBatch(entries, llm, embedding, options = {}) {
       maxSimilarity: calculateClusterMaxSimilarity(cluster, embeddings)
     });
   }
+  const totalArbitratedEntries = arbitrationTasks.reduce((sum, task) => sum + task.cluster.length, 0);
+  let completedClusters = 0;
+  let completedEntries = 0;
   const arbitrationResults = await runBoundedArbitrations(
     arbitrationTasks,
     concurrency,
-    async (task) => arbitrateCluster(task.clusterIndex, task.cluster, entries, llm, task.maxSimilarity)
+    async (task) => arbitrateCluster(task.clusterIndex, task.cluster, entries, llm, task.maxSimilarity),
+    (task) => {
+      completedClusters += 1;
+      completedEntries += task.cluster.length;
+      options.onProgress?.({
+        completedClusters,
+        totalClusters: arbitrationTasks.length,
+        completedEntries,
+        totalEntries: totalArbitratedEntries
+      });
+    }
   );
   for (const arbitration of arbitrationResults) {
     clusterDetails.push(arbitration.detail);
@@ -1151,7 +1164,7 @@ function normalizeDedupConcurrency(value) {
   }
   return value;
 }
-async function runBoundedArbitrations(tasks, concurrency, worker) {
+async function runBoundedArbitrations(tasks, concurrency, worker, onTaskComplete) {
   if (tasks.length === 0) {
     return [];
   }
@@ -1171,6 +1184,7 @@ async function runBoundedArbitrations(tasks, concurrency, worker) {
           return;
         }
         results[taskIndex] = await worker(task, taskIndex);
+        onTaskComplete?.(task, taskIndex);
       }
     })
   );
@@ -1957,7 +1971,8 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
       {
         concurrency: options.concurrency ?? DEFAULT_INGEST_CONCURRENCY,
         skip: options.skipDedup,
-        verbose: options.verbose
+        verbose: options.verbose,
+        onProgress: options.onDedupProgress
       }
     );
     const preservedDedupResult = {
@@ -1997,7 +2012,8 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
         if (flattenedIndex >= 0) {
           claimKeyDiagnostics.set(flattenedIndex, diagnostic);
         }
-      }
+      },
+      options.onClaimExtractionProgress
     );
     for (const [entry, extractedClaimKey] of extractedClaimKeys) {
       applyClaimExtractionResultToEntry(entry, extractedClaimKey);
@@ -3354,7 +3370,13 @@ function registerIngestEntriesCommand(parent) {
             spinner5?.message(`Processing transcripts... (${completed}/${total} extracted)`);
           },
           onStageProgress: (event) => {
-            spinner5?.message(progressMessageForIngestStage(event, files.length));
+            spinner5?.message(progressMessageForIngestStage(event));
+          },
+          onDedupProgress: (event) => {
+            spinner5?.message(progressMessageForDedup(event));
+          },
+          onClaimExtractionProgress: (event) => {
+            spinner5?.message(progressMessageForClaimExtraction(event));
           },
           onBulkWriteProgress: useVerboseBulkWriteProgress ? reportBulkWriteProgress : (event) => {
             spinner5?.message(progressMessageForBulkWrite(event.phase));
@@ -3749,16 +3771,27 @@ function emptyStoreResult2() {
     rejected: 0
   };
 }
-function progressMessageForIngestStage(event, totalFiles) {
+function progressMessageForIngestStage(event) {
   switch (event.phase) {
     case "dedup_start":
-      return `Deduplicating ${event.totalEntries} ${pluralize2(event.totalEntries, "entry", "entries")} from ${totalFiles} ${pluralize2(totalFiles, "file")}...`;
+      return "Deduplicating entries...";
     case "claim_extraction_start":
-      return `Extracting claim keys for ${event.totalEntries} ${pluralize2(event.totalEntries, "entry", "entries")}...`;
+      return "Extracting claim keys...";
     case "store_start":
       return `Running store pipeline for ${event.totalEntries} ${pluralize2(event.totalEntries, "entry", "entries")}...`;
   }
 }
+function progressMessageForDedup(event) {
+  return `Deduplicating entries... ${event.completedClusters}/${event.totalClusters} ${pluralize2(event.totalClusters, "cluster")} arbitrated (${event.completedEntries}/${event.totalEntries} entries covered)`;
+}
+function progressMessageForClaimExtraction(event) {
+  switch (event.phase) {
+    case "primary":
+      return `Extracting claim keys... ${event.completedEntries}/${event.totalEntries} entries`;
+    case "retry":
+      return `Retrying unresolved claim keys... ${event.completedEntries}/${event.totalEntries} entries`;
+  }
+}
 function progressMessageForBulkWrite(phase) {
   switch (phase) {
     case "prepare_start":

package/dist/internal-recall-eval-server.js

@@ -23,7 +23,7 @@ import {
   resolveEmbeddingApiKey,
   resolveEmbeddingModel,
   runUnifiedRecall
-} from "./chunk-LVDQXSHP.js";
+} from "./chunk-SQARNOYD.js";
 import {
   recall
 } from "./chunk-GUDCFFRV.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "Agent memory - local-first knowledge infrastructure for AI agents",
   "type": "module",
   "bin": {
@@ -12,24 +12,6 @@
     "LICENSE",
     "CHANGELOG.md"
   ],
-  "scripts": {
-    "build": "pnpm run build:root && pnpm run build:plugin",
-    "build:root": "tsup",
-    "build:plugin": "pnpm --filter @agenr/agenr-plugin build",
-    "build:debug": "pnpm run build:root:debug && pnpm run build:plugin:debug",
-    "build:root:debug": "tsup --sourcemap",
-    "build:plugin:debug": "pnpm --filter @agenr/agenr-plugin build:debug",
-    "dev": "tsup --watch",
-    "internal:recall-eval-server": "pnpm run build:root && node dist/internal-recall-eval-server.js",
-    "check": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm test",
-    "typecheck": "tsc --noEmit",
-    "typecheck:tests": "tsc --noEmit -p tsconfig.tests.json",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "dependencies": {
     "@mariozechner/pi-agent-core": "^0.63.1",
     "@mariozechner/pi-ai": "^0.63.2",
@@ -55,5 +37,23 @@
   "engines": {
     "node": ">=24"
   },
-  "license": "AGPL-3.0"
-}
+  "license": "AGPL-3.0",
+  "scripts": {
+    "build": "pnpm run build:root && pnpm run build:plugin",
+    "build:root": "tsup",
+    "build:plugin": "pnpm --filter @agenr/agenr-plugin build",
+    "build:debug": "pnpm run build:root:debug && pnpm run build:plugin:debug",
+    "build:root:debug": "tsup --sourcemap",
+    "build:plugin:debug": "pnpm --filter @agenr/agenr-plugin build:debug",
+    "dev": "tsup --watch",
+    "internal:recall-eval-server": "pnpm run build:root && node dist/internal-recall-eval-server.js",
+    "check": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm test",
+    "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc --noEmit -p tsconfig.tests.json",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}