agenr 1.8.0 → 1.8.2

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [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.
+
+### Fixed
+
+- **Dedup now honors bounded concurrency.** Multi-entry similarity clusters are now arbitrated in parallel with deterministic result ordering, and ingest paths explicitly thread configured/default concurrency into dedup instead of leaving arbitration serial.
+- **Claim extraction now uses real batch concurrency without violating ordered semantics.** Batch claim-key extraction now honors configured concurrency, preserves past-only hint visibility via per-entry frozen hint snapshots, and propagates sensible defaults through the relevant ingest/store paths instead of falling back to historical hardcoded single-worker behavior.
+- **Ingest spinner now reports real post-extraction stages.** Non-verbose `agenr ingest entries` runs now surface dedup, claim-key extraction, store pipeline, and bulk-write index preparation/finalization stages instead of looking stuck after `(N/N extracted)`.
+
+### Validation
+
+Changes since last push to `origin/master`:
+
+- Enhance ingestion process with stage progress events
+- Refactor deduplication process to support configurable concurrency
+- Refactor concurrency handling in ingestion process
+
 ## [1.8.0] - 2026-04-11
 
 Claim-centric trust loop close-out release.

package/dist/adapters/openclaw/index.js

@@ -7,7 +7,7 @@ import {
   parseTuiSessionKey,
   readOpenClawSessionsStore,
   storeEntriesDetailed
-} from "../../chunk-6CEKKEFZ.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";
@@ -1055,7 +1055,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "1.8.0",
+  version: "1.8.1",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {

package/dist/{chunk-6CEKKEFZ.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();
   }
@@ -2746,8 +2746,14 @@ async function runBatchClaimExtraction(results, ports, config, _concurrency = 10
   const extractedEntries = /* @__PURE__ */ new Map();
   const diagnostics = /* @__PURE__ */ new Map();
   const retryEntries = [];
-  for (const result of results) {
-    for (const entry of result.entries) {
+  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 = [];
+    for (const entry of stageEntries) {
       if (entry.claim_key) {
         recordClaimKeyHint(hintState, entry.claim_key);
         continue;
@@ -2765,7 +2771,29 @@ async function runBatchClaimExtraction(results, ports, config, _concurrency = 10
         });
         continue;
       }
-      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintState, onWarning);
+      stageRequests.push({
+        entry,
+        hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
+      });
+    }
+    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);
       if (decision.result?.claimKey) {
         applyClaimExtractionResultToEntry(entry, decision.result);
@@ -2777,18 +2805,40 @@ async function runBatchClaimExtraction(results, ports, config, _concurrency = 10
     }
   }
   if (retryEntries.length > 0 && extractedEntries.size > 0) {
-    for (const entry of retryEntries) {
-      if (entry.claim_key) {
-        continue;
-      }
-      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintState, onWarning);
-      diagnostics.set(entry, decision.diagnostic);
-      if (!decision.result?.claimKey) {
-        continue;
+    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 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);
+        if (!decision.result?.claimKey) {
+          continue;
+        }
+        applyClaimExtractionResultToEntry(entry, decision.result);
+        recordClaimKeyHint(hintState, decision.result.claimKey);
+        extractedEntries.set(entry, decision.result);
       }
-      applyClaimExtractionResultToEntry(entry, decision.result);
-      recordClaimKeyHint(hintState, decision.result.claimKey);
-      extractedEntries.set(entry, decision.result);
     }
   }
   for (const result of results) {
@@ -2801,7 +2851,34 @@ async function runBatchClaimExtraction(results, ports, config, _concurrency = 10
   }
   return extractedEntries;
 }
-async function extractBatchClaimKeyDecision(entry, llm, config, hintState, onWarning) {
+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;
+  }
+  return value;
+}
+function buildClaimExtractionHintSnapshot(hintState, entry) {
+  return {
+    hints: buildEntryHints(hintState, entry),
+    supportClaimKeys: [...hintState.supportClaimKeys],
+    entityPrefixStats: hintState.entityPrefixStats
+  };
+}
+async function extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning) {
   try {
     return await extractClaimKeyDecision(
       {
@@ -2814,10 +2891,10 @@ async function extractBatchClaimKeyDecision(entry, llm, config, hintState, onWar
       llm,
       config,
       {
-        hints: buildEntryHints(hintState, entry),
+        hints: hintSnapshot.hints,
         onWarning,
-        supportClaimKeys: [...hintState.supportClaimKeys],
-        entityPrefixStats: hintState.entityPrefixStats
+        supportClaimKeys: hintSnapshot.supportClaimKeys,
+        entityPrefixStats: hintSnapshot.entityPrefixStats
       }
     );
   } catch {
@@ -3735,7 +3812,7 @@ async function maybeExtractClaimKeys(preparedEntries, options) {
         db: claimExtraction.db
       },
       claimExtraction.config,
-      1,
+      claimExtraction.config.concurrency ?? 10,
       options.onWarning,
       (entry, diagnostic) => {
         const preparedEntry = preparedEntries.find((candidate) => candidate.input === entry);

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-6CEKKEFZ.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,
@@ -1053,11 +1053,13 @@ async function sleep(durationMs) {
 
 // src/core/ingestion/dedup.ts
 var DEFAULT_SIMILARITY_THRESHOLD = 0.75;
+var DEFAULT_DEDUP_CONCURRENCY = 10;
 function getDefaultDedupSimilarityThreshold() {
   return DEFAULT_SIMILARITY_THRESHOLD;
 }
 async function dedupBatch(entries, llm, embedding, options = {}) {
   const similarityThreshold = options.similarityThreshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+  const concurrency = normalizeDedupConcurrency(options.concurrency);
   if (entries.length === 0) {
     return {
       survivors: [],
@@ -1085,8 +1087,8 @@ async function dedupBatch(entries, llm, embedding, options = {}) {
   const survivorByIndex = /* @__PURE__ */ new Map();
   const clusterDetails = [];
   const warnings = [];
+  const arbitrationTasks = [];
   let singletonsPassedThrough = 0;
-  let llmCalls = 0;
   for (const [clusterIndex, cluster] of clusters.entries()) {
     if (cluster.length === 1) {
       const entryIndex = cluster[0];
@@ -1096,15 +1098,37 @@ async function dedupBatch(entries, llm, embedding, options = {}) {
       }
       continue;
     }
-    const maxSimilarity = calculateClusterMaxSimilarity(cluster, embeddings);
-    const arbitration = await arbitrateCluster(clusterIndex, cluster, entries, llm, maxSimilarity);
-    llmCalls += 1;
+    arbitrationTasks.push({
+      clusterIndex,
+      cluster,
+      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),
+    (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);
     if (arbitration.warning) {
       warnings.push(arbitration.warning);
     }
     for (const keptIndex of arbitration.detail.kept) {
-      const updatedEntry = arbitration.detail.merged === true && arbitration.detail.mergedContent && keptIndex === arbitration.detail.mergeTarget ? mergeClusterEntry(cluster, keptIndex, arbitration.detail.mergedContent, entries) : entries[keptIndex];
+      const updatedEntry = arbitration.detail.merged === true && arbitration.detail.mergedContent && keptIndex === arbitration.detail.mergeTarget ? mergeClusterEntry(arbitration.detail.entryIndices, keptIndex, arbitration.detail.mergedContent, entries) : entries[keptIndex];
       survivorByIndex.set(keptIndex, updatedEntry);
     }
   }
@@ -1128,12 +1152,44 @@ async function dedupBatch(entries, llm, embedding, options = {}) {
     removedCount: entries.length - survivors.length,
     clustersArbitrated: clusterDetails.length,
     singletonsPassedThrough,
-    llmCalls,
+    llmCalls: arbitrationTasks.length,
     clusterDetails,
     warnings,
     similarityThreshold
   };
 }
+function normalizeDedupConcurrency(value) {
+  if (!Number.isInteger(value) || value === void 0 || value <= 0) {
+    return DEFAULT_DEDUP_CONCURRENCY;
+  }
+  return value;
+}
+async function runBoundedArbitrations(tasks, concurrency, worker, onTaskComplete) {
+  if (tasks.length === 0) {
+    return [];
+  }
+  const results = new Array(tasks.length);
+  const workerCount = Math.min(concurrency, tasks.length);
+  let nextTaskIndex = 0;
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (true) {
+        const taskIndex = nextTaskIndex;
+        nextTaskIndex += 1;
+        if (taskIndex >= tasks.length) {
+          return;
+        }
+        const task = tasks[taskIndex];
+        if (task === void 0) {
+          return;
+        }
+        results[taskIndex] = await worker(task, taskIndex);
+        onTaskComplete?.(task, taskIndex);
+      }
+    })
+  );
+  return results;
+}
 async function arbitrateCluster(clusterIndex, cluster, entries, llm, maxSimilarity) {
   const systemPrompt = buildDedupSystemPrompt();
   const userPrompt = buildDedupUserPrompt(cluster, entries);
@@ -1901,14 +1957,22 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
   let precomputedEmbeddings;
   const claimKeyDiagnostics = /* @__PURE__ */ new Map();
   if (taggedEntries.length > 0) {
+    if (options.skipDedup !== true) {
+      options.onStageProgress?.({
+        phase: "dedup_start",
+        totalEntries: taggedEntries.length
+      });
+    }
     const dedupLlm = options.skipDedup === true ? createNoopLlmPort() : ports.createDedupLlm?.() ?? ports.createExtractionLlm();
     dedupResult = await dedupBatch(
       taggedEntries.map((taggedEntry) => taggedEntry.entry),
       dedupLlm,
       ports.embedding,
       {
+        concurrency: options.concurrency ?? DEFAULT_INGEST_CONCURRENCY,
         skip: options.skipDedup,
-        verbose: options.verbose
+        verbose: options.verbose,
+        onProgress: options.onDedupProgress
       }
     );
     const preservedDedupResult = {
@@ -1928,6 +1992,12 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
       confidenceThreshold: 0.8,
       eligibleTypes: ["fact", "preference", "decision", "lesson"]
     };
+    if (claimConfig.enabled) {
+      options.onStageProgress?.({
+        phase: "claim_extraction_start",
+        totalEntries: flattenEntries(resultsToStore).length
+      });
+    }
     const extractedClaimKeys = await runBatchClaimExtraction(
       resultsToStore,
       {
@@ -1935,14 +2005,15 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
         db: ports.db
       },
       claimConfig,
-      options.concurrency ?? DEFAULT_INGEST_CONCURRENCY,
+      claimConfig.concurrency ?? options.concurrency ?? DEFAULT_INGEST_CONCURRENCY,
       options.onWarning,
       (entry, diagnostic) => {
         const flattenedIndex = findFlattenedEntryIndex(resultsToStore, entry);
         if (flattenedIndex >= 0) {
           claimKeyDiagnostics.set(flattenedIndex, diagnostic);
         }
-      }
+      },
+      options.onClaimExtractionProgress
     );
     for (const [entry, extractedClaimKey] of extractedClaimKeys) {
       applyClaimExtractionResultToEntry(entry, extractedClaimKey);
@@ -1957,20 +2028,26 @@ async function ingestDiscoveredFiles(files, ports, options = {}) {
       eligibleTypes: ["fact", "preference", "decision", "lesson"]
     }).eligibleTypes
   ) : null;
-  const storeResults = resultsToStore.length === 0 ? /* @__PURE__ */ new Map() : await storeExtractedResults(
-    resultsToStore,
-    {
-      db: ports.db,
-      embedding: ports.embedding
-    },
-    {
-      dryRun: options.dryRun,
-      verbose: options.verbose,
-      precomputedEmbeddings,
-      onWarning: options.onWarning,
-      onBulkWriteProgress: options.onBulkWriteProgress
-    }
-  );
+  const storeResults = resultsToStore.length === 0 ? /* @__PURE__ */ new Map() : await (async () => {
+    options.onStageProgress?.({
+      phase: "store_start",
+      totalEntries: flattenEntries(resultsToStore).length
+    });
+    return storeExtractedResults(
+      resultsToStore,
+      {
+        db: ports.db,
+        embedding: ports.embedding
+      },
+      {
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        precomputedEmbeddings,
+        onWarning: options.onWarning,
+        onBulkWriteProgress: options.onBulkWriteProgress
+      }
+    );
+  })();
   return {
     files,
     extractionRuns,
@@ -3217,7 +3294,7 @@ function registerIngestCommand(program2) {
   registerIngestEpisodesCommand(ingestCommand);
 }
 function registerIngestEntriesCommand(parent) {
-  const ingestCommand = parent.command("entries <path>", { isDefault: true }).description("Ingest OpenClaw session files into the knowledge database").option("--verbose", "Show detailed progress").option("--dry-run", "Parse and extract without storing").addOption(new Option2("--whole-file <mode>", "Whole-file mode: auto|force|never").choices(["auto", "force", "never"]).default("auto")).option("--skip-dedup", "Skip within-batch semantic dedup").addOption(new Option2("--concurrency <n>", "Max files to extract in parallel").argParser(parseConcurrency).default(DEFAULT_INGEST_CONCURRENCY));
+  const ingestCommand = parent.command("entries <path>", { isDefault: true }).description("Ingest OpenClaw session files into the knowledge database").option("--verbose", "Show detailed progress").option("--dry-run", "Parse and extract without storing").addOption(new Option2("--whole-file <mode>", "Whole-file mode: auto|force|never").choices(["auto", "force", "never"]).default("auto")).option("--skip-dedup", "Skip within-batch semantic dedup").addOption(new Option2("--concurrency <n>", "Max files to extract in parallel").argParser(parseConcurrency));
   ingestCommand.action(async (targetPath, options) => {
     const startedAt = Date.now();
     let db = null;
@@ -3231,6 +3308,11 @@ function registerIngestEntriesCommand(parent) {
       const { provider, modelId } = resolveModel(config, "extraction");
       const { provider: dedupProvider, modelId: dedupModelId } = resolveModel(config, "dedup");
       const claimExtractionConfig = resolveClaimExtractionConfig(config);
+      const effectiveConcurrency = commandInput.concurrency ?? claimExtractionConfig.concurrency ?? DEFAULT_INGEST_CONCURRENCY;
+      const cliClaimExtractionConfig = {
+        ...claimExtractionConfig,
+        concurrency: effectiveConcurrency
+      };
       const claimModel = claimExtractionConfig.enabled ? resolveModel(config, "claim") : null;
       const llmApiKey = resolveLlmApiKey(config, provider);
       const dedupApiKey = resolveLlmApiKey(config, dedupProvider);
@@ -3254,7 +3336,7 @@ function registerIngestEntriesCommand(parent) {
           formatLabel("Whole-file", commandInput.wholeFile),
           formatLabel("Within-batch dedup", commandInput.skipDedup ? "skipped" : "enabled"),
           formatLabel("Embeddings", "stored"),
-          formatLabel("Concurrency", `${commandInput.concurrency}`)
+          formatLabel("Concurrency", `${effectiveConcurrency}`)
         ].join("\n")
       );
       if (commandInput.dryRun) {
@@ -3277,8 +3359,8 @@ function registerIngestEntriesCommand(parent) {
           } : {}
         },
         {
-          concurrency: commandInput.concurrency,
-          claimExtractionConfig,
+          concurrency: effectiveConcurrency,
+          claimExtractionConfig: cliClaimExtractionConfig,
           dryRun: commandInput.dryRun,
           verbose: commandInput.verbose,
           wholeFile: commandInput.wholeFile,
@@ -3287,7 +3369,18 @@ function registerIngestEntriesCommand(parent) {
           onExtractionProgress: (completed, total) => {
             spinner5?.message(`Processing transcripts... (${completed}/${total} extracted)`);
           },
-          onBulkWriteProgress: useVerboseBulkWriteProgress ? reportBulkWriteProgress : void 0
+          onStageProgress: (event) => {
+            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));
+          }
         }
       );
       spinner5?.stop("Ingest pipeline complete.");
@@ -3396,7 +3489,7 @@ function normalizeIngestEntriesCommand(targetPath, options) {
     dryRun: options.dryRun === true,
     wholeFile: options.wholeFile ?? "auto",
     skipDedup: options.skipDedup === true,
-    concurrency: options.concurrency ?? DEFAULT_INGEST_CONCURRENCY
+    concurrency: options.concurrency
   };
 }
 function formatClaimKeyHealthSummary(summary) {
@@ -3678,6 +3771,39 @@ function emptyStoreResult2() {
     rejected: 0
   };
 }
+function progressMessageForIngestStage(event) {
+  switch (event.phase) {
+    case "dedup_start":
+      return "Deduplicating entries...";
+    case "claim_extraction_start":
+      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":
+      return "Preparing database indexes for bulk ingest...";
+    case "store_complete":
+      return "Bulk ingest store phase complete...";
+    case "finalize_start":
+      return "Rebuilding indexes after bulk ingest...";
+    case "finalize_complete":
+      return "Bulk ingest finalization complete...";
+  }
+}
 function reportBulkWriteProgress(event) {
   switch (event.phase) {
     case "prepare_start":
@@ -5334,7 +5460,7 @@ async function runBulkIngest(files, config, prompts) {
           spinner5.message(`Ingesting sessions... (${completed}/${total} extracted)`);
         },
         onBulkWriteProgress: (event) => {
-          spinner5.message(progressMessageForBulkWrite(event.phase));
+          spinner5.message(progressMessageForBulkWrite2(event.phase));
         }
       }
     );
@@ -5433,7 +5559,7 @@ function normalizeSetupProvider(provider) {
 function hasMeteredIngestCost(auth) {
   return auth !== "openai-subscription" && auth !== "anthropic-oauth" && auth !== "anthropic-token";
 }
-function progressMessageForBulkWrite(phase) {
+function progressMessageForBulkWrite2(phase) {
   switch (phase) {
     case "prepare_start":
       return "Preparing database indexes for bulk ingest...";

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.0",
+  "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"
+  }
+}