agenr 0.9.74 → 0.9.75

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.9.75] - 2026-03-07
+
+### Changed
+
+- OpenClaw session-start memory injection now runs browse/core recall through a dedicated startup selector that favors continuity utility over raw browse ordering, suppresses overlap with `Recent session`, and applies hard section caps before rendering.
+- Session-start startup memory now treats `fact`, `event`, `lesson`, `relationship`, and `reflection` intentionally instead of sending all residual non-core entries into one broad startup bucket.
+- The session-start composer now reserves space for `Memory Index` before rendering `Recent memory`, so aggressive char trimming keeps recovery breadcrumbs whenever they still fit.
+
+### Fixed
+
+- OpenClaw session-start dedupe now records only the entry IDs that actually survive selector filtering and prompt rendering, so startup-trimmed entries remain eligible for later mid-session recall.
+- Session-start selector freshness now treats missing or malformed `updated_at` values conservatively as stale instead of accidentally boosting them as fresh.
+- Tightened session-start exact-state detection to require structured operational state such as active branch/worktree/cwd, numbered PR or issue references, concrete path or file state, or explicit config/env/version state.
+- Added a narrow older-continuity escape hatch so importance-7 lessons, relationships, and exact-state or open-thread facts can survive beyond the freshness window when they still materially affect current work.
+- OpenClaw session-start browse candidate assembly now prefetches a small larger pool, caps `reflection` entries before the final 10-slot cutoff, and backfills remaining slots by existing browse score so durable non-reflection entries are not starved upstream of the selector.
+- Tightened OpenClaw session-start selector admission for historical decisions and preferences so high importance now boosts ranking only after current behavioral, exact-state, or real continuity evidence is present.
+- Made session-start `openThread` detection more precise by treating weak narrative words like `next`, `continue`, and `fix` as continuity signals only when they are very recent, while preserving stronger unfinished-work cues.
+- Removed a redundant post-classification cosmetic-preference filter from session-start selection and added regression coverage for stale high-importance decisions and weak versus strong continuity wording.
+
 ## [0.9.74] - 2026-03-07
 
 ### Added

package/dist/{chunk-KTBSXLVU.js → chunk-AQN6BP74.js}

@@ -3,12 +3,12 @@ import {
   getDb,
   initDb,
   normalizeProject
-} from "./chunk-PAO647AF.js";
+} from "./chunk-HEE4JOTJ.js";
 import {
   toNumber,
   toRowsAffected,
   toStringValue
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 
 // src/openclaw-plugin/plugin-db.ts
 var CREATE_SEEN_SESSIONS_TABLE_SQL = `

package/dist/{chunk-PAO647AF.js → chunk-HEE4JOTJ.js}

@@ -3,7 +3,7 @@ import {
   parseDaysBetween,
   toNumber,
   toStringValue
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 
 // src/utils/errors.ts
 function toErrorMessage(error) {

package/dist/{chunk-JH355OHS.js → chunk-PUBBITKQ.js}

@@ -17,14 +17,14 @@ import {
   runSimpleStream,
   toErrorMessage,
   walCheckpoint
-} from "./chunk-PAO647AF.js";
+} from "./chunk-HEE4JOTJ.js";
 import {
   MILLISECONDS_PER_DAY,
   getCoRecallNeighbors,
   parseDaysBetween,
   toNumber,
   toStringValue
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 
 // src/utils/parse.ts
 function parsePositiveInt(value, fallback, label) {

package/dist/{chunk-Z7MN65K2.js → chunk-UGIJJOPV.js}

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/utils/entry-utils.ts
 var MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
 function toNumber(value) {
@@ -321,6 +327,7 @@ async function getTopCoRecallEdges(db, limit = 20) {
 }
 
 export {
+  __export,
   MILLISECONDS_PER_DAY,
   toNumber,
   toStringValue,

package/dist/cli-main.js

@@ -9,7 +9,7 @@ import {
   rehabilitateEntry,
   resolveOpenClawWatcherSessionProjectState,
   resolveReview
-} from "./chunk-KTBSXLVU.js";
+} from "./chunk-AQN6BP74.js";
 import {
   ConflictAlreadyResolvedError,
   DEFAULT_AROUND_RADIUS_DAYS,
@@ -70,7 +70,7 @@ import {
   toRecord,
   updateRecallMetadata,
   warnIfLocked
-} from "./chunk-JH355OHS.js";
+} from "./chunk-PUBBITKQ.js";
 import {
   APP_VERSION,
   DEFAULT_DB_PATH,
@@ -131,7 +131,7 @@ import {
   toErrorMessage,
   walCheckpoint,
   writeConfig
-} from "./chunk-PAO647AF.js";
+} from "./chunk-HEE4JOTJ.js";
 import {
   getCoRecallNeighbors,
   getTopCoRecallEdges,
@@ -139,7 +139,7 @@ import {
   toNumber,
   toRowsAffected,
   toStringValue
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 
 // src/cli-main.ts
 import * as clack18 from "@clack/prompts";
@@ -14795,7 +14795,7 @@ async function processTarget(params) {
           try {
             const existingIds = await queue.runExclusive(() => getSourceEntryIds(db, target.file));
             if (existingIds.size >= 2) {
-              const { strengthenCoRecallEdges, MAX_USED_ENTRIES } = await import("./co-recall-MOA5R4D6.js");
+              const { strengthenCoRecallEdges, MAX_USED_ENTRIES } = await import("./co-recall-VWYTWS7P.js");
               const idArr = [...existingIds].slice(0, MAX_USED_ENTRIES);
               const expectedEdges = idArr.length * (idArr.length - 1) / 2;
               const edgeCount = await queue.runExclusive(async () => {
@@ -14966,7 +14966,7 @@ async function processTarget(params) {
       try {
         const fileEntryIds = await queue.runExclusive(() => getSourceEntryIds(db, target.file));
         if (fileEntryIds.size >= 2) {
-          const { strengthenCoRecallEdges } = await import("./co-recall-MOA5R4D6.js");
+          const { strengthenCoRecallEdges } = await import("./co-recall-VWYTWS7P.js");
           const edgeTimestamp = resolvedDeps.nowFn().toISOString();
           await queue.runExclusive(() => strengthenCoRecallEdges(db, [...fileEntryIds], edgeTimestamp));
         }
@@ -18950,12 +18950,12 @@ function registerMaintainCommand(program) {
     "--only <tasks>",
     "Comma-separated task names: quality,edge-decay,clusters,conflicts,consolidation,retirement,reflection"
   ).option("--prune-edges", "When edge decay runs, delete edges below the configured decay floor").option("--verbose", "Show detailed per-task output").action(async (opts) => {
-    const { runMaintainCommand } = await import("./maintain-CKA7EVOW.js");
+    const { runMaintainCommand } = await import("./maintain-QRHVQ45A.js");
     const result = await runMaintainCommand(opts);
     process.exitCode = result.exitCode;
   });
   maintainCommand.command("history").description("Show past maintenance runs").option("--db <path>", "Database path override").option("--limit <n>", "Max runs to show (default: 10)", parseIntOption).option("--json", "Output as JSON").action(async (opts) => {
-    const { runMaintainHistoryCommand } = await import("./maintain-CKA7EVOW.js");
+    const { runMaintainHistoryCommand } = await import("./maintain-QRHVQ45A.js");
     const result = await runMaintainHistoryCommand(opts);
     process.exitCode = result.exitCode;
   });

package/dist/{co-recall-MOA5R4D6.js → co-recall-VWYTWS7P.js}

@@ -6,7 +6,7 @@ import {
   getLastRecallActivity,
   getTopCoRecallEdges,
   strengthenCoRecallEdges
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 export {
   MAX_USED_ENTRIES,
   decayCoRecallEdges,

package/dist/{maintain-CKA7EVOW.js → maintain-QRHVQ45A.js}

@@ -27,7 +27,7 @@ import {
   resolveModelForLlmClient,
   runConsolidationOrchestrator,
   toRecord
-} from "./chunk-JH355OHS.js";
+} from "./chunk-PUBBITKQ.js";
 import {
   DEFAULT_DB_PATH,
   DEFAULT_TASK_MODEL,
@@ -43,14 +43,14 @@ import {
   resolveEmbeddingApiKey,
   runSimpleStream,
   walCheckpoint
-} from "./chunk-PAO647AF.js";
+} from "./chunk-HEE4JOTJ.js";
 import {
   decayCoRecallEdges,
   getLastRecallActivity,
   parseDaysBetween,
   toNumber,
   toStringValue
-} from "./chunk-Z7MN65K2.js";
+} from "./chunk-UGIJJOPV.js";
 
 // src/llm/maintain-llm.ts
 var MaintainLlmError = class extends Error {

package/dist/openclaw-plugin/index.js

@@ -7,7 +7,7 @@ import {
   getSessionProjectState,
   resolveProjectWorthySessionProject,
   setSessionProject
-} from "../chunk-KTBSXLVU.js";
+} from "../chunk-AQN6BP74.js";
 import {
   KNOWLEDGE_TYPES,
   SCOPE_LEVELS,
@@ -20,13 +20,14 @@ import {
   resolveProjectScopeFromSlug,
   runSimpleStream,
   toErrorMessage
-} from "../chunk-PAO647AF.js";
+} from "../chunk-HEE4JOTJ.js";
 import {
   MILLISECONDS_PER_DAY,
+  __export,
   strengthenCoRecallEdges,
   toNumber,
   toStringValue
-} from "../chunk-Z7MN65K2.js";
+} from "../chunk-UGIJJOPV.js";
 
 // src/openclaw-plugin/index.ts
 import os3 from "os";
@@ -615,6 +616,19 @@ function formatMidSessionRecall(results, options = {}) {
 }
 
 // src/openclaw-plugin/recall.ts
+var recall_exports = {};
+__export(recall_exports, {
+  buildSpawnArgs: () => buildSpawnArgs2,
+  fetchCoreEntries: () => fetchCoreEntries,
+  formatCoreAsMarkdown: () => formatCoreAsMarkdown,
+  formatMemoryIndex: () => formatMemoryIndex,
+  formatRecallAsMarkdown: () => formatRecallAsMarkdown,
+  renderRecallAsMarkdown: () => renderRecallAsMarkdown,
+  resolveAgenrPath: () => resolveAgenrPath,
+  resolveBudget: () => resolveBudget,
+  runMemoryIndex: () => runMemoryIndex,
+  runRecall: () => runRecall
+});
 import { spawn as spawn2 } from "child_process";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -891,10 +905,14 @@ function groupValidEntries(result, options = {}) {
     if (options.excludeCore && isCoreRecallItem(item)) {
       continue;
     }
-    const groupedEntry = normalizeGroupedEntry(entry, options.addCoreMetadata === true);
-    if (TODO_TYPES.has(entry.type)) {
+    const groupedEntry = {
+      item,
+      entry: normalizeGroupedEntry(entry, options.addCoreMetadata === true)
+    };
+    const explicitCategory = item.category;
+    if (explicitCategory === "active" || TODO_TYPES.has(entry.type)) {
       grouped.todos.push(groupedEntry);
-    } else if (PREFERENCE_TYPES.has(entry.type)) {
+    } else if (explicitCategory === "preferences" || PREFERENCE_TYPES.has(entry.type)) {
       grouped.preferences.push(groupedEntry);
     } else {
       grouped.facts.push(groupedEntry);
@@ -911,17 +929,21 @@ function collectCoreEntries(result) {
     if (!isCoreRecallItem(item) || !isValidEntry(item.entry)) {
       continue;
     }
-    entries.push(normalizeGroupedEntry(item.entry, true));
+    entries.push({
+      item,
+      entry: normalizeGroupedEntry(item.entry, true)
+    });
   }
   return sortCorePriority(entries);
 }
 function buildSectionMarkdown(header, entries, maxEntryChars, maxChars) {
   if (entries.length === 0 || maxChars <= 0) {
-    return { markdown: "", entryCount: 0 };
+    return { markdown: "", entryCount: 0, renderedItems: [] };
   }
   const lines = [];
   let totalChars = 0;
   let entryCount = 0;
+  const renderedItems = [];
   const tryPushLine = (line) => {
     const nextLength = totalChars + (lines.length > 0 ? 1 : 0) + line.length;
     if (nextLength > maxChars) {
@@ -932,20 +954,21 @@ function buildSectionMarkdown(header, entries, maxEntryChars, maxChars) {
     return true;
   };
   if (!tryPushLine(header) || !tryPushLine("")) {
-    return { markdown: "", entryCount: 0 };
+    return { markdown: "", entryCount: 0, renderedItems: [] };
   }
   for (const entry of entries) {
-    const line = `- [${entry.subject}] ${truncateEntryContent(entry.content, maxEntryChars)}`;
+    const line = `- [${entry.entry.subject}] ${truncateEntryContent(entry.entry.content, maxEntryChars)}`;
     if (!tryPushLine(line)) {
       break;
     }
     entryCount += 1;
+    renderedItems.push(entry.item);
   }
   if (entryCount === 0) {
-    return { markdown: "", entryCount: 0 };
+    return { markdown: "", entryCount: 0, renderedItems: [] };
   }
   tryPushLine("");
-  return { markdown: lines.join("\n").trimEnd(), entryCount };
+  return { markdown: lines.join("\n").trimEnd(), entryCount, renderedItems };
 }
 function createBlockAccumulator(maxChars) {
   const blocks = [];
@@ -970,6 +993,9 @@ function createBlockAccumulator(maxChars) {
   };
 }
 function formatRecallAsMarkdown(result, options = {}) {
+  return renderRecallAsMarkdown(result, options).markdown;
+}
+function renderRecallAsMarkdown(result, options = {}) {
   const maxEntryChars = resolveFormatLimit(
     options.maxEntryChars,
     DEFAULT_FORMAT_MAX_ENTRY_CHARS2
@@ -978,36 +1004,46 @@ function formatRecallAsMarkdown(result, options = {}) {
   const coreMaxChars = resolveFormatLimit(options.coreMaxChars, maxChars);
   return formatRecallWithLimits(result, maxEntryChars, maxChars, {
     coreMaxChars,
-    includeRootHeader: options.includeRootHeader !== false
+    includeRootHeader: options.includeRootHeader !== false,
+    recentSectionHeader: options.recentSectionHeader ?? "### Facts and Events"
   });
 }
+function formatCoreAsMarkdown(result, options = {}) {
+  const maxEntryChars = resolveFormatLimit(
+    options.maxEntryChars,
+    DEFAULT_FORMAT_MAX_ENTRY_CHARS2
+  );
+  const maxChars = resolveFormatLimit(options.maxChars, DEFAULT_FORMAT_MAX_CHARS2);
+  return formatCoreWithLimits(result, maxEntryChars, maxChars);
+}
 function sortCorePriority(entries) {
   return [...entries].sort((a, b) => {
-    const aUniversal = a._isUniversal ?? false;
-    const bUniversal = b._isUniversal ?? false;
+    const aUniversal = a.entry._isUniversal ?? false;
+    const bUniversal = b.entry._isUniversal ?? false;
     if (aUniversal !== bUniversal) {
       return aUniversal ? -1 : 1;
     }
-    const aImportance = a._importance ?? 0;
-    const bImportance = b._importance ?? 0;
+    const aImportance = a.entry._importance ?? 0;
+    const bImportance = b.entry._importance ?? 0;
     if (aImportance !== bImportance) {
       return bImportance - aImportance;
     }
-    return a.subject.localeCompare(b.subject);
+    return a.entry.subject.localeCompare(b.entry.subject);
   });
 }
 function formatRecallWithLimits(result, maxEntryChars, maxChars, options) {
   if (!result.results || result.results.length === 0) {
-    return "";
+    return { markdown: "", renderedItems: [] };
   }
   const coreEntries = collectCoreEntries(result);
   const { todos, preferences, facts } = groupValidEntries(result, { excludeCore: true });
   if (coreEntries.length === 0 && todos.length === 0 && preferences.length === 0 && facts.length === 0) {
-    return "";
+    return { markdown: "", renderedItems: [] };
   }
   const blocks = createBlockAccumulator(maxChars);
+  const renderedItems = [];
   if (options.includeRootHeader && !blocks.tryPushBlock("## agenr Memory Context", 0)) {
-    return blocks.finalize();
+    return { markdown: blocks.finalize(), renderedItems };
   }
   if (coreEntries.length > 0) {
     const coreBudget = Math.min(blocks.remainingChars(), options.coreMaxChars);
@@ -1018,13 +1054,47 @@ function formatRecallWithLimits(result, maxEntryChars, maxChars, options) {
       coreBudget
     );
     if (!blocks.tryPushBlock(coreSection.markdown, coreSection.entryCount)) {
-      return blocks.finalize();
+      return { markdown: blocks.finalize(), renderedItems };
     }
+    renderedItems.push(...coreSection.renderedItems);
   }
   for (const [header, entries] of [
     ["### Active Todos", todos],
     ["### Preferences and Decisions", preferences],
-    ["### Facts and Events", facts]
+    [options.recentSectionHeader, facts]
+  ]) {
+    const section = buildSectionMarkdown(
+      header,
+      entries,
+      maxEntryChars,
+      blocks.remainingChars()
+    );
+    if (!blocks.tryPushBlock(section.markdown, section.entryCount)) {
+      return { markdown: blocks.finalize(), renderedItems };
+    }
+    renderedItems.push(...section.renderedItems);
+  }
+  return { markdown: blocks.finalize(), renderedItems };
+}
+function formatCoreWithLimits(result, maxEntryChars, maxChars) {
+  if (!result.results || result.results.length === 0) {
+    return "";
+  }
+  let { todos, preferences, facts } = groupValidEntries(result, { addCoreMetadata: true });
+  todos = sortCorePriority(todos);
+  preferences = sortCorePriority(preferences);
+  facts = sortCorePriority(facts);
+  if (todos.length === 0 && preferences.length === 0 && facts.length === 0) {
+    return "";
+  }
+  const blocks = createBlockAccumulator(maxChars);
+  if (!blocks.tryPushBlock("### Core Context", 0)) {
+    return blocks.finalize();
+  }
+  for (const [header, entries] of [
+    ["#### Active Todos", todos],
+    ["#### Preferences and Decisions", preferences],
+    ["#### Facts and Events", facts]
   ]) {
     const section = buildSectionMarkdown(
       header,
@@ -2641,6 +2711,576 @@ async function runHandoffForSession(opts) {
 import os from "os";
 import path4 from "path";
 
+// src/openclaw-plugin/session-start-selector.ts
+var DEFAULT_SESSION_START_SECTION_CAPS = {
+  core: 6,
+  active: 4,
+  preferences: 4,
+  recent: 2
+};
+var CATEGORY_PRIORITY = {
+  core: 0,
+  active: 1,
+  preferences: 2,
+  recent: 3
+};
+var BEHAVIOR_KEYWORDS = [
+  "always",
+  "avoid",
+  "constraint",
+  "default",
+  "do not",
+  "don't",
+  "format",
+  "must",
+  "must not",
+  "never",
+  "policy",
+  "rule",
+  "style",
+  "workflow"
+];
+var STRONG_OPEN_THREAD_KEYWORDS = [
+  "blocker",
+  "blocked",
+  "failing",
+  "follow up",
+  "follow-up",
+  "in progress",
+  "open thread",
+  "pending",
+  "stuck",
+  "todo",
+  "unfinished",
+  "waiting",
+  "wip"
+];
+var WEAK_OPEN_THREAD_KEYWORDS = [
+  "continue",
+  "fix",
+  "next",
+  "remaining",
+  "resume"
+];
+var OPERATIONAL_KEYWORDS = [
+  "build",
+  "check",
+  "command",
+  "debug",
+  "deploy",
+  "install",
+  "rerun",
+  "run",
+  "ship",
+  "test",
+  "verify",
+  "write"
+];
+var RELATIONSHIP_KEYWORDS = [
+  "blocked by",
+  "contact",
+  "depends on",
+  "maintainer",
+  "owner",
+  "paired with",
+  "reviewer"
+];
+var ARCHIVAL_KEYWORDS = [
+  "closed",
+  "completed",
+  "deprecated",
+  "done",
+  "fixed",
+  "historical",
+  "launched",
+  "merged",
+  "released",
+  "resolved",
+  "retired",
+  "shipped",
+  "used to"
+];
+var COSMETIC_PREFERENCE_KEYWORDS = [
+  "dark mode",
+  "font",
+  "screenshot",
+  "theme",
+  "ui"
+];
+var EXACT_STATE_PATH_HINT_PATTERN = /\b(?:cwd|file|path|repo path|worktree)\b/i;
+var EXACT_STATE_PATH_VALUE_PATTERN = /(?:^|[\s(])(?:~\/|\/[^\s)]+|[A-Za-z0-9._-]+\/[A-Za-z0-9._/-]+|[A-Za-z0-9._-]+\.[A-Za-z0-9]{1,8})(?=$|[\s),])/;
+var EXACT_STATE_ISSUE_PATTERN = /\b(?:pr|issue)\s*#?\d+\b/i;
+var EXACT_STATE_COMMIT_PATTERN = /\bcommit\b/i;
+var EXACT_STATE_COMMIT_HASH_PATTERN = /\b[0-9a-f]{7,40}\b/i;
+var EXACT_STATE_TAG_PATTERN = /\btag\b/i;
+var EXACT_STATE_ENV_PATTERN = /\b(?:env|environment)\b/i;
+var EXACT_STATE_CONFIG_PATTERN = /\bconfig\b/i;
+var EXACT_STATE_VERSION_PATTERN = /\bversion\b/i;
+var EXACT_STATE_STATEFUL_PATTERN = /\b(?:active|current|disabled|enabled|pinned|points to|running|set to|using)\b/i;
+var EXACT_STATE_ENV_ASSIGNMENT_PATTERN = /\b[A-Z][A-Z0-9_]{1,}=[^\s]+\b/;
+var EXACT_STATE_SEMVER_PATTERN = /\bv?\d+\.\d+(?:\.\d+)?\b/i;
+var IMPORTANCE_SEVEN_CONTINUITY_MAX_AGE_DAYS = 120;
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize(value) {
+  return normalizeText(value).split(" ").map((token) => token.trim()).filter((token) => token.length >= 4);
+}
+function toTimestamp(value) {
+  if (typeof value !== "string") {
+    return 0;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function containsKeyword(text, keywords) {
+  return keywords.some((keyword) => text.includes(keyword));
+}
+function hasOpenThreadSignal(text, veryRecent) {
+  if (containsKeyword(text, STRONG_OPEN_THREAD_KEYWORDS)) {
+    return true;
+  }
+  return veryRecent && containsKeyword(text, WEAK_OPEN_THREAD_KEYWORDS);
+}
+function overlapRatio(candidateText, referenceTokens) {
+  if (referenceTokens.size === 0) {
+    return 0;
+  }
+  const tokens = new Set(tokenize(candidateText));
+  if (tokens.size === 0) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const token of tokens) {
+    if (referenceTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap / tokens.size;
+}
+function subjectKey(item) {
+  const subject = typeof item.entry?.subject === "string" ? normalizeText(item.entry.subject) : "";
+  return subject ? `subject:${subject}` : null;
+}
+function contentKey(item) {
+  const content = typeof item.entry?.content === "string" ? normalizeText(item.entry.content) : "";
+  return content ? `content:${content.slice(0, 200)}` : null;
+}
+function exactKey(item) {
+  const id = typeof item.entry?.id === "string" ? item.entry.id.trim() : "";
+  if (id) {
+    return `id:${id}`;
+  }
+  const type = typeof item.entry?.type === "string" ? item.entry.type.trim() : "";
+  const subject = typeof item.entry?.subject === "string" ? normalizeText(item.entry.subject) : "";
+  const content = typeof item.entry?.content === "string" ? normalizeText(item.entry.content) : "";
+  if (!type || !subject || !content) {
+    return null;
+  }
+  return `entry:${type}\0${subject}\0${content}`;
+}
+function buildOverlapKeys(item) {
+  return [exactKey(item), subjectKey(item), contentKey(item)].filter((value) => Boolean(value));
+}
+function getImportance(item) {
+  const rawImportance = item.entry?.importance;
+  return typeof rawImportance === "number" && Number.isFinite(rawImportance) ? rawImportance : 0;
+}
+function getAgeDays(item, now) {
+  const updatedAt = toTimestamp(item.entry?.updated_at);
+  if (updatedAt <= 0 || now <= 0) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, (now - updatedAt) / (24 * 60 * 60 * 1e3));
+}
+function hasExactStateSignal(subject, content) {
+  const text = normalizeText(`${subject} ${content}`);
+  const rawText = `${subject} ${content}`;
+  if (containsKeyword(text, ["branch", "cwd", "worktree"])) {
+    return true;
+  }
+  if (EXACT_STATE_ISSUE_PATTERN.test(rawText)) {
+    return true;
+  }
+  if (EXACT_STATE_COMMIT_PATTERN.test(text) && EXACT_STATE_COMMIT_HASH_PATTERN.test(rawText)) {
+    return true;
+  }
+  if (EXACT_STATE_TAG_PATTERN.test(text) && EXACT_STATE_SEMVER_PATTERN.test(rawText)) {
+    return true;
+  }
+  if (EXACT_STATE_PATH_HINT_PATTERN.test(text) && EXACT_STATE_PATH_VALUE_PATTERN.test(rawText)) {
+    return true;
+  }
+  if (EXACT_STATE_ENV_PATTERN.test(text)) {
+    return EXACT_STATE_ENV_ASSIGNMENT_PATTERN.test(rawText) || EXACT_STATE_STATEFUL_PATTERN.test(text);
+  }
+  if (EXACT_STATE_CONFIG_PATTERN.test(text) && EXACT_STATE_STATEFUL_PATTERN.test(text)) {
+    return true;
+  }
+  if (EXACT_STATE_VERSION_PATTERN.test(text) && EXACT_STATE_SEMVER_PATTERN.test(rawText) && EXACT_STATE_STATEFUL_PATTERN.test(text)) {
+    return true;
+  }
+  return false;
+}
+function buildSignals(item, now) {
+  const subject = typeof item.entry?.subject === "string" ? item.entry.subject : "";
+  const content = typeof item.entry?.content === "string" ? item.entry.content : "";
+  const text = normalizeText(`${subject} ${content}`);
+  const ageDays = getAgeDays(item, now);
+  const exactState = hasExactStateSignal(subject, content);
+  const veryRecent = ageDays <= 3;
+  const openThread = hasOpenThreadSignal(text, veryRecent);
+  const behaviorImpact = openThread || containsKeyword(text, BEHAVIOR_KEYWORDS);
+  const operational = behaviorImpact || exactState || containsKeyword(text, OPERATIONAL_KEYWORDS);
+  const strongRelationship = containsKeyword(text, RELATIONSHIP_KEYWORDS);
+  return {
+    archival: containsKeyword(text, ARCHIVAL_KEYWORDS),
+    behaviorImpact,
+    exactState,
+    fresh: ageDays <= 14,
+    operational,
+    openThread,
+    recent: ageDays <= 30,
+    strongRelationship,
+    veryRecent
+  };
+}
+function hasImportanceSevenContinuityEscape(item, signals, now) {
+  const importance = getImportance(item);
+  if (importance < 7 || importance >= 8 || signals.archival) {
+    return false;
+  }
+  const ageDays = getAgeDays(item, now);
+  if (!Number.isFinite(ageDays) || ageDays <= 14 || ageDays > IMPORTANCE_SEVEN_CONTINUITY_MAX_AGE_DAYS) {
+    return false;
+  }
+  switch (item.entry?.type) {
+    case "lesson":
+      return signals.operational;
+    case "relationship":
+      return signals.strongRelationship;
+    case "fact":
+    case "event":
+      return signals.exactState || signals.behaviorImpact && signals.openThread;
+    default:
+      return false;
+  }
+}
+function classifyCandidate(item, signals, now) {
+  const expiry = item.category === "core" || item.entry?.expiry === "core";
+  if (expiry) {
+    return "core";
+  }
+  const type = item.entry?.type;
+  const importance = getImportance(item);
+  const ageDays = getAgeDays(item, now);
+  const recentEnough = ageDays <= 14;
+  if (type === "todo") {
+    return "active";
+  }
+  if (type === "decision" || type === "preference") {
+    const text = normalizeText(`${item.entry?.subject ?? ""} ${item.entry?.content ?? ""}`);
+    const hasCurrentEffect = signals.behaviorImpact || signals.exactState || signals.openThread;
+    if (type === "preference" && importance < 8 && !signals.exactState && !signals.openThread && containsKeyword(text, COSMETIC_PREFERENCE_KEYWORDS)) {
+      return null;
+    }
+    if (signals.archival && !hasCurrentEffect) {
+      return null;
+    }
+    if (hasCurrentEffect) {
+      return "preferences";
+    }
+    return null;
+  }
+  if (type === "reflection") {
+    if (signals.behaviorImpact && signals.openThread && signals.veryRecent && importance >= 9) {
+      return "recent";
+    }
+    return null;
+  }
+  if (type === "relationship") {
+    if (!signals.strongRelationship && !signals.behaviorImpact && !signals.exactState) {
+      return null;
+    }
+    if (recentEnough || importance >= 8 || hasImportanceSevenContinuityEscape(item, signals, now)) {
+      return "recent";
+    }
+    return null;
+  }
+  if (type === "lesson") {
+    if (!signals.operational) {
+      return null;
+    }
+    if (recentEnough || importance >= 8 || hasImportanceSevenContinuityEscape(item, signals, now)) {
+      return "recent";
+    }
+    return null;
+  }
+  if (type === "fact" || type === "event") {
+    if (!signals.exactState && !signals.openThread && !signals.behaviorImpact && item.score < 0.8) {
+      return null;
+    }
+    if (signals.archival && !signals.openThread && !signals.exactState) {
+      return null;
+    }
+    if (recentEnough || importance >= 8 || hasImportanceSevenContinuityEscape(item, signals, now)) {
+      return "recent";
+    }
+    return null;
+  }
+  return null;
+}
+function computeUtility(item, category, signals, now) {
+  const importance = getImportance(item);
+  const ageDays = getAgeDays(item, now);
+  let utility = item.score * 5 + importance * 0.7;
+  if (category === "core") {
+    utility += 10;
+  } else if (category === "active") {
+    utility += 6;
+  } else if (category === "preferences") {
+    utility += 4;
+  } else {
+    utility += 1;
+  }
+  if (signals.behaviorImpact) {
+    utility += 3;
+  }
+  if (signals.exactState) {
+    utility += 3;
+  }
+  if (signals.openThread) {
+    utility += 4;
+  }
+  if (signals.operational) {
+    utility += 2;
+  }
+  if (signals.veryRecent) {
+    utility += 2;
+  } else if (signals.fresh) {
+    utility += 1;
+  } else if (ageDays > 30) {
+    utility -= 2;
+  }
+  if (signals.archival) {
+    utility -= 3;
+  }
+  if (item.entry?.type === "relationship") {
+    utility -= 1;
+  }
+  return utility;
+}
+function isRedundantWithRecentSession(item, recentSessionText, recentSessionTokens) {
+  if (!recentSessionText) {
+    return false;
+  }
+  const rawSubject = typeof item.entry?.subject === "string" ? item.entry.subject : "";
+  const rawContent = typeof item.entry?.content === "string" ? item.entry.content : "";
+  const subject = normalizeText(rawSubject);
+  const content = normalizeText(rawContent);
+  if (subject && recentSessionText.includes(subject)) {
+    return true;
+  }
+  if (content.length >= 24 && recentSessionText.includes(content.slice(0, 160))) {
+    return true;
+  }
+  const overlap = overlapRatio(`${subject} ${content}`, recentSessionTokens);
+  if (subject.includes("session handoff") && overlap >= 0.45) {
+    return true;
+  }
+  if (hasExactStateSignal(rawSubject, rawContent) && overlap >= 0.45) {
+    return true;
+  }
+  return overlap >= 0.55;
+}
+function compareCandidates(a, b) {
+  if (b.utility !== a.utility) {
+    return b.utility - a.utility;
+  }
+  if (CATEGORY_PRIORITY[a.category] !== CATEGORY_PRIORITY[b.category]) {
+    return CATEGORY_PRIORITY[a.category] - CATEGORY_PRIORITY[b.category];
+  }
+  return b.updatedAt - a.updatedAt;
+}
+function roundRobinOrder(groups, maxNonCoreEntries) {
+  const ordered = [];
+  const categories = ["active", "preferences", "recent"];
+  let index = 0;
+  while (ordered.length < maxNonCoreEntries) {
+    let addedThisRound = false;
+    for (const category of categories) {
+      const candidate = groups[category][index];
+      if (!candidate) {
+        continue;
+      }
+      ordered.push(candidate);
+      addedThisRound = true;
+      if (ordered.length >= maxNonCoreEntries) {
+        return ordered;
+      }
+    }
+    if (!addedThisRound) {
+      break;
+    }
+    index += 1;
+  }
+  return ordered;
+}
+function selectSessionStartMemory(coreResult, browseResult, options = {}) {
+  const now = options.now?.getTime() ?? Date.now();
+  const sectionCaps = {
+    ...DEFAULT_SESSION_START_SECTION_CAPS,
+    ...options.sectionCaps
+  };
+  const maxNonCoreEntries = options.maxNonCoreEntries ?? Number.POSITIVE_INFINITY;
+  const recentSessionText = normalizeText(options.recentSessionText ?? "");
+  const recentSessionTokens = new Set(tokenize(recentSessionText));
+  const coreCandidates = [];
+  const nonCoreCandidates = [];
+  for (const item of coreResult?.results ?? []) {
+    const signals = buildSignals(item, now);
+    coreCandidates.push({
+      item: {
+        ...item,
+        category: "core"
+      },
+      category: "core",
+      overlapKeys: buildOverlapKeys(item),
+      utility: computeUtility(item, "core", signals, now),
+      updatedAt: toTimestamp(item.entry?.updated_at)
+    });
+  }
+  for (const item of browseResult?.results ?? []) {
+    const signals = buildSignals(item, now);
+    const category = classifyCandidate(item, signals, now);
+    if (!category || category === "core") {
+      continue;
+    }
+    if (isRedundantWithRecentSession(item, recentSessionText, recentSessionTokens)) {
+      continue;
+    }
+    nonCoreCandidates.push({
+      item: {
+        ...item,
+        category
+      },
+      category,
+      overlapKeys: buildOverlapKeys(item),
+      utility: computeUtility(item, category, signals, now),
+      updatedAt: toTimestamp(item.entry?.updated_at)
+    });
+  }
+  coreCandidates.sort(compareCandidates);
+  nonCoreCandidates.sort(compareCandidates);
+  const seenOverlapKeys = /* @__PURE__ */ new Set();
+  const selectedCore = [];
+  for (const candidate of coreCandidates) {
+    const overlaps = candidate.overlapKeys.some((key) => seenOverlapKeys.has(key));
+    if (overlaps) {
+      continue;
+    }
+    selectedCore.push(candidate);
+    for (const key of candidate.overlapKeys) {
+      seenOverlapKeys.add(key);
+    }
+    if (selectedCore.length >= sectionCaps.core) {
+      break;
+    }
+  }
+  const grouped = {
+    core: selectedCore,
+    active: [],
+    preferences: [],
+    recent: []
+  };
+  for (const candidate of nonCoreCandidates) {
+    if (grouped[candidate.category].length >= sectionCaps[candidate.category]) {
+      continue;
+    }
+    const overlaps = candidate.overlapKeys.some((key) => seenOverlapKeys.has(key));
+    if (overlaps) {
+      continue;
+    }
+    grouped[candidate.category].push(candidate);
+    for (const key of candidate.overlapKeys) {
+      seenOverlapKeys.add(key);
+    }
+  }
+  const selectedNonCore = roundRobinOrder(grouped, maxNonCoreEntries);
+  const results = [
+    ...grouped.core.map((candidate) => candidate.item),
+    ...grouped.active.filter((candidate) => selectedNonCore.includes(candidate)).map((candidate) => candidate.item),
+    ...grouped.preferences.filter((candidate) => selectedNonCore.includes(candidate)).map((candidate) => candidate.item),
+    ...grouped.recent.filter((candidate) => selectedNonCore.includes(candidate)).map((candidate) => candidate.item)
+  ];
+  if (results.length === 0) {
+    return null;
+  }
+  return {
+    query: browseResult?.query ?? coreResult?.query ?? "[session-start]",
+    results
+  };
+}
+
+// src/openclaw-plugin/session-start-browse.ts
+var SESSION_START_BROWSE_CANDIDATE_LIMIT = 10;
+var SESSION_START_BROWSE_MIN_IMPORTANCE = 7;
+var SESSION_START_BROWSE_PREFETCH_MULTIPLIER = 3;
+var SESSION_START_BROWSE_PREFETCH_LIMIT = SESSION_START_BROWSE_CANDIDATE_LIMIT * SESSION_START_BROWSE_PREFETCH_MULTIPLIER;
+var SESSION_START_BROWSE_TYPE_CAPS = {
+  reflection: 3
+};
+function normalizeType(item) {
+  const rawType = item.entry?.type;
+  return typeof rawType === "string" ? rawType.trim().toLowerCase() : "";
+}
+function diversifySessionStartBrowseCandidates(browseResult, limit = SESSION_START_BROWSE_CANDIDATE_LIMIT, typeCaps = SESSION_START_BROWSE_TYPE_CAPS) {
+  if (!browseResult) {
+    return null;
+  }
+  const normalizedLimit = Math.max(0, Math.floor(limit));
+  if (normalizedLimit === 0 || browseResult.results.length === 0) {
+    return {
+      ...browseResult,
+      results: []
+    };
+  }
+  const admittedIndexes = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  const selected = [];
+  for (const [index, item] of browseResult.results.entries()) {
+    if (selected.length >= normalizedLimit) {
+      break;
+    }
+    const type = normalizeType(item);
+    const cap = typeCaps[type];
+    const count = counts.get(type) ?? 0;
+    if (cap !== void 0 && count >= cap) {
+      continue;
+    }
+    selected.push(item);
+    admittedIndexes.add(index);
+    if (type) {
+      counts.set(type, count + 1);
+    }
+  }
+  if (selected.length < normalizedLimit) {
+    for (const [index, item] of browseResult.results.entries()) {
+      if (selected.length >= normalizedLimit) {
+        break;
+      }
+      if (admittedIndexes.has(index)) {
+        continue;
+      }
+      selected.push(item);
+    }
+  }
+  return {
+    ...browseResult,
+    results: selected
+  };
+}
+
 // src/openclaw-plugin/heartbeat.ts
 var HEARTBEAT_FILE_PATTERN = /\bHEARTBEAT\.md\b/i;
 function isHeartbeatPoll(message) {
@@ -2764,10 +3404,14 @@ var DEFAULT_MID_SESSION_RECALL_MODE = "hybrid";
 var DEFAULT_STORE_NUDGE_THRESHOLD = 8;
 var DEFAULT_STORE_NUDGE_MAX_PER_SESSION = 5;
 var DEFAULT_SESSION_START_BUDGET_CHARS = 12e3;
-var SESSION_START_BROWSE_LIMIT = 10;
-var SESSION_START_BROWSE_MIN_IMPORTANCE = 7;
 var SESSION_START_CORE_MAX_CHARS = 4e3;
+var SESSION_START_MEMORY_INDEX_MAX_CHARS = 1200;
+var SESSION_START_NON_CORE_MAX_ENTRIES = DEFAULT_SESSION_START_SECTION_CAPS.active + DEFAULT_SESSION_START_SECTION_CAPS.preferences + DEFAULT_SESSION_START_SECTION_CAPS.recent;
+var SESSION_START_RECENT_HEADER = "### State and Continuity";
+var SESSION_START_RECENT_SESSION_MAX_CHARS = 1200;
+var SESSION_START_SECTION_TRUNCATION_NOTICE = "\n[Section truncated]";
 var SESSION_START_TRUNCATION_NOTICE = "\n\n[Memory context truncated at budget]";
+var SESSION_START_MEMORY_BLOCK_HEADER = "## Recent memory\n";
 var SESSION_START_FORMAT_OPTIONS = {
   maxEntryChars: 500,
   maxChars: 5e3
@@ -2838,21 +3482,32 @@ function getRecallEntryDedupKey(item) {
   }
   return `content:${type}\0${subject}\0${content}`;
 }
-function mergeSessionStartMemoryResults(coreResult, browseResult) {
-  const results = [
-    ...(coreResult?.results ?? []).map((item) => ({
-      ...item,
-      category: "core"
-    })),
-    ...browseResult?.results ?? []
-  ];
-  if (results.length === 0) {
-    return null;
+function capSectionText(text, maxChars, notice = SESSION_START_SECTION_TRUNCATION_NOTICE) {
+  if (!text || maxChars <= 0) {
+    return "";
+  }
+  if (text.length <= maxChars) {
+    return text;
+  }
+  if (maxChars <= notice.length) {
+    return "";
+  }
+  return `${text.slice(0, maxChars - notice.length).trimEnd()}${notice}`;
+}
+function pushCappedSection(blocks, block, hardCapChars) {
+  if (!block) {
+    return;
+  }
+  const remaining = hardCapChars - blocks.reduce((sum, existing, index) => {
+    return sum + existing.length + (index > 0 ? 2 : 0);
+  }, 0) - (blocks.length > 0 ? 2 : 0);
+  if (remaining <= 0) {
+    return;
+  }
+  const capped = capSectionText(block, remaining, SESSION_START_TRUNCATION_NOTICE);
+  if (capped) {
+    blocks.push(capped);
   }
-  return {
-    query: browseResult?.query ?? coreResult?.query ?? "[session-start]",
-    results
-  };
 }
 function formatProjectScope(projects) {
   const normalizedProjects = Array.from(
@@ -3198,7 +3853,7 @@ async function handleBeforePromptBuild(event, ctx, params) {
       const browseRecallOptions = {
         context: "browse",
         since: "30d",
-        limit: SESSION_START_BROWSE_LIMIT,
+        limit: SESSION_START_BROWSE_PREFETCH_LIMIT,
         minImportance: SESSION_START_BROWSE_MIN_IMPORTANCE
       };
       if (!sessionStartBrowseProject) {
@@ -3256,6 +3911,12 @@ async function handleBeforePromptBuild(event, ctx, params) {
           return !key || !coreEntryKeys.has(key);
         });
       }
+      if (browseResult) {
+        browseResult.results = diversifySessionStartBrowseCandidates(
+          browseResult,
+          SESSION_START_BROWSE_CANDIDATE_LIMIT
+        )?.results ?? [];
+      }
       if (browseResult) {
         debugLog(
           params.debug,
@@ -3308,48 +3969,75 @@ async function handleBeforePromptBuild(event, ctx, params) {
           `filtered ${browseResult.results.length - browseResultForContext.results.length} session handoff entries after explicit clear`
         );
       }
-      const sessionStartMemory = mergeSessionStartMemoryResults(coreResult, browseResultForContext);
+      const hardCapChars = resolveSessionStartBudgetChars(params.config);
       const sections = [];
       const sessionProjectSection = formatSessionProjectStateSection(sessionProjectResolution);
       if (sessionProjectSection) {
-        sections.push(sessionProjectSection);
+        pushCappedSection(sections, sessionProjectSection, hardCapChars);
       }
-      if (previousTurns.trim()) {
-        sections.push(`## Recent session
-${previousTurns.trim()}`);
+      const recentSessionBody = capSectionText(
+        previousTurns.trim(),
+        SESSION_START_RECENT_SESSION_MAX_CHARS
+      );
+      if (recentSessionBody) {
+        pushCappedSection(sections, `## Recent session
+${recentSessionBody}`, hardCapChars);
       }
+      const memoryIndexSection = capSectionText(
+        memoryIndexMarkdown?.trim() ?? "",
+        SESSION_START_MEMORY_INDEX_MAX_CHARS
+      );
+      const sessionStartMemory = selectSessionStartMemory(
+        coreResult,
+        browseResultForContext,
+        {
+          maxNonCoreEntries: SESSION_START_NON_CORE_MAX_ENTRIES,
+          recentSessionText: recentSessionBody
+        }
+      );
+      const renderedStartupItems = [];
       if (sessionStartMemory) {
-        const formatted = formatRecallAsMarkdown(
-          sessionStartMemory,
-          {
-            ...SESSION_START_FORMAT_OPTIONS,
-            coreMaxChars: SESSION_START_CORE_MAX_CHARS,
-            includeRootHeader: false
-          }
+        const reservedForMemoryIndex = memoryIndexSection ? memoryIndexSection.length + 2 : 0;
+        const usedBeforeMemory = sections.reduce((sum, block, index) => {
+          return sum + block.length + (index > 0 ? 2 : 0);
+        }, 0);
+        const availableForMemory = Math.max(
+          0,
+          hardCapChars - usedBeforeMemory - reservedForMemoryIndex - (sections.length > 0 ? 2 : 0)
+        );
+        const memoryBodyBudget = Math.max(0, availableForMemory - SESSION_START_MEMORY_BLOCK_HEADER.length);
+        const renderOptions = {
+          ...SESSION_START_FORMAT_OPTIONS,
+          maxChars: Math.min(SESSION_START_FORMAT_OPTIONS.maxChars ?? memoryBodyBudget, memoryBodyBudget),
+          coreMaxChars: SESSION_START_CORE_MAX_CHARS,
+          includeRootHeader: false,
+          recentSectionHeader: SESSION_START_RECENT_HEADER
+        };
+        const formatted = formatRecallAsMarkdown(sessionStartMemory, renderOptions).trim();
+        const renderRecallAsMarkdown2 = Reflect.get(
+          recall_exports,
+          "renderRecallAsMarkdown"
         );
-        if (formatted.trim()) {
-          sections.push(`## Recent memory
-${formatted.trim()}`);
+        const renderedMemory = typeof renderRecallAsMarkdown2 === "function" ? renderRecallAsMarkdown2(sessionStartMemory, renderOptions) : {
+          markdown: formatted,
+          renderedItems: formatted ? sessionStartMemory.results : []
+        };
+        if (formatted) {
+          pushCappedSection(sections, `${SESSION_START_MEMORY_BLOCK_HEADER}${formatted}`, hardCapChars);
+          renderedStartupItems.push(...renderedMemory.renderedItems);
         }
       }
-      if (memoryIndexMarkdown?.trim()) {
-        sections.push(memoryIndexMarkdown);
+      if (memoryIndexSection) {
+        pushCappedSection(sections, memoryIndexSection, hardCapChars);
       }
       markdown = sections.length > 0 ? sections.join("\n\n") : void 0;
-      const hardCapChars = resolveSessionStartBudgetChars(params.config);
       if (markdown && markdown.length > hardCapChars) {
         const retainedLength = Math.max(0, hardCapChars - SESSION_START_TRUNCATION_NOTICE.length);
         markdown = `${markdown.slice(0, retainedLength)}${SESSION_START_TRUNCATION_NOTICE}`;
       }
       debugLog(params.debug, "session-start", `prependContext chars=${markdown?.length ?? 0}`);
       const recalledIds = /* @__PURE__ */ new Set();
-      for (const item of coreResult?.results ?? []) {
-        const id = getRecallEntryId(item);
-        if (id) {
-          recalledIds.add(id);
-        }
-      }
-      for (const item of browseResultForContext?.results ?? []) {
+      for (const item of renderedStartupItems) {
         const id = getRecallEntryId(item);
         if (id) {
           recalledIds.add(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.9.74",
+  "version": "0.9.75",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"