agenr 1.8.1 → 1.9.0

package/CHANGELOG.md

@@ -2,6 +2,70 @@
 
 ## [Unreleased]
 
+## [1.9.0] - 2026-04-12
+
+Surgeon autonomy, review-flow hardening, and CLI/runtime polish release.
+
+### Added
+
+- **Surgeon autonomy control plane v1.** Agenr now ships the first full surgeon autonomy control plane with stronger proposal-review flow, improved review ownership, and better runtime state handling across autonomous passes.
+- **Architecture review skill.** Added a dedicated architecture review skill to support repository-level structural review work alongside the surgeon and planning toolchain updates in this release window.
+
+### Changed
+
+- **Surgeon architecture and runtime boundaries are cleaner.** Surgeon logic was refactored across app, adapter, and domain seams, with generalized prompts across corpus domains, tighter runtime safeguards, simplified run flow, and more coherent completion/progress accounting.
+- **CLI and trace output are more structured.** Surgeon console output, startup summaries, progress rendering, and trace logging were tightened so autonomous runs are easier to monitor and debug.
+- **Local development scaffolding stays out of git status.** `.gitignore` now excludes the repo-local skills directory to keep local agent tooling from polluting release and day-to-day workflow status.
+
+### Fixed
+
+- **Autonomous surgeon passes recover more reliably.** Fixed proposal-loop stalling, autonomous backup handling, trace directory handling, exhausted-review completion, and repeat supersession-review suppression so long-running surgeon activity can finish cleanly.
+
+### Validation
+
+Changes since last push to `origin/master`:
+
+- Clean up surgeon CLI output with structured progress and chalk formatting
+- Simplify surgeon run flow
+- Fix surgeon trace directory handling
+- Compact surgeon trace logging
+- Implement surgeon autonomy control plane v1
+- Fix surgeon autonomous proposal loop
+- Fix surgeon autonomous backup and progress stalling
+- Stabilize surgeon retirement and proposal passes
+- Generalize surgeon prompts across corpus domains
+- Add first-principles planning skill
+- Tighten surgeon runtime safeguards
+- Update `.gitignore` to include skills directory
+- Remove first-principles planning skill and associated OpenAI agent configuration files
+- Finish supersession completion on exhausted reviews
+- Improve surgeon progress accounting and console output
+- Suppress repeat supersession review and polish surgeon CLI output
+- Add architecture review skill
+- Refactor surgeon architecture boundaries
+- Clarify surgeon pass startup summaries
+
+## [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-I6A6DPNF.js";
 import {
   EMBEDDING_DIMENSIONS,
   ENTRY_TYPES,
@@ -24,7 +24,7 @@ import {
   resolveEmbeddingModel,
   runUnifiedRecall,
   validateTemporalValidityRange
-} from "../../chunk-LVDQXSHP.js";
+} from "../../chunk-EMRMV2QR.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.1",
+  version: "1.9.0",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {

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

@@ -1932,6 +1932,10 @@ var CREATE_SURGEON_RUN_PROPOSALS_REVIEW_STATUS_INDEX_SQL = `
   CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_review_status
   ON surgeon_run_proposals(review_status)
 `;
+var CREATE_SURGEON_RUN_PROPOSALS_OPEN_ISSUE_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_open_issue
+  ON surgeon_run_proposals(review_status, group_id, issue_kind)
+`;
 var CREATE_META_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS _meta (
     key TEXT PRIMARY KEY,
@@ -2055,6 +2059,7 @@ var SCHEMA_STATEMENTS = [
   CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL,
   CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL,
   CREATE_SURGEON_RUN_PROPOSALS_REVIEW_STATUS_INDEX_SQL,
+  CREATE_SURGEON_RUN_PROPOSALS_OPEN_ISSUE_INDEX_SQL,
   CREATE_META_TABLE_SQL,
   CREATE_ENTRIES_CONTENT_HASH_INDEX_SQL,
   CREATE_ENTRIES_NORM_CONTENT_HASH_INDEX_SQL,
@@ -4094,6 +4099,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 +4262,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 +4465,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/{chunk-O45JQ6O3.js → chunk-I6A6DPNF.js}

@@ -22,7 +22,7 @@ import {
   readOptionalString,
   readRequiredString,
   validateTemporalValidityRange
-} from "./chunk-LVDQXSHP.js";
+} from "./chunk-EMRMV2QR.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;