@agenr/agenr-plugin 3.0.0 → 3.1.0

package/dist/{chunk-LAXNNWHM.js → chunk-EEEL53X4.js}

@@ -21,8 +21,9 @@ import {
   readNumber,
   readOptionalString,
   readRequiredString,
+  truncate,
   validateTemporalValidityRange
-} from "./chunk-ELR2HSVC.js";
+} from "./chunk-NNO2V4GH.js";
 import {
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
@@ -36,6 +37,166 @@ import {
   validateExtractedClaimKey
 } from "./chunk-5LADPJ4C.js";
 
+// src/adapters/shared/errors.ts
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/adapters/shared/resolve-target.ts
+function buildEntryMemoryResolverPorts(services) {
+  return {
+    getEntryById: async (entryId) => await services.entries.getEntry(entryId) ?? (await services.memory.getEntryTrace(entryId))?.entry ?? null,
+    findEntryBySubject: async (subject) => services.memory.findEntryBySubject(subject),
+    findMostRecentEntry: async () => services.memory.findMostRecentEntry()
+  };
+}
+async function resolveTargetEntry(ports, params, options = {}) {
+  const id = readOptionalStringParam(params, "id");
+  const subject = readOptionalStringParam(params, "subject");
+  const last = options.allowLast ? readBooleanParam(params, "last") : void 0;
+  const selectorCount = (id ? 1 : 0) + (subject ? 1 : 0) + (last === true ? 1 : 0);
+  const selectorDescription = options.allowLast ? "id, subject, or last" : "id or subject";
+  if (selectorCount !== 1) {
+    throw new Error(`Provide exactly one target selector: ${selectorDescription}.`);
+  }
+  if (last) {
+    const entry2 = await ports.findMostRecentEntry();
+    if (!entry2) {
+      throw new Error("No agenr entries exist yet.");
+    }
+    return entry2;
+  }
+  if (id) {
+    const entry2 = await ports.getEntryById(id);
+    if (!entry2) {
+      throw new Error(`No agenr entry found for id ${id}.`);
+    }
+    return entry2;
+  }
+  const entry = await ports.findEntryBySubject(subject ?? "");
+  if (!entry) {
+    throw new Error(`No agenr entry found for subject "${subject}".`);
+  }
+  return entry;
+}
+function readBooleanParam(params, key) {
+  const value = params[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(`${key} must be a boolean.`);
+}
+function readOptionalStringParam(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string.`);
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+
+// src/adapters/shared/entry-tools.ts
+var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use fact for durable truth about a person, system, place, or how something works. Use decision for a standing rule, constraint, policy, or chosen approach future sessions should follow - not a progress update or completed action. Use preference for what someone likes, wants, values, or wants avoided. Use lesson for a non-obvious takeaway learned from experience that should change future behavior. Use milestone for a rare one-time event with durable future significance - not ordinary execution progress. Use relationship for a meaningful durable connection between people, groups, or systems.";
+var EXPIRY_DESCRIPTION = "Lifetime bucket: core (always injected at session start, use sparingly), permanent (durable and recalled on demand), or temporary (short-horizon).";
+var UPDATE_EXPIRY_DESCRIPTION = `${EXPIRY_DESCRIPTION} Accepted values: ${EXPIRY_LEVELS.join(", ")}.`;
+var RECALL_MODES = ["auto", "entries", "episodes", "procedures"];
+function asRecord(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  throw new Error("Tool parameters must be an object.");
+}
+function parseExpiry(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (EXPIRY_LEVELS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported expiry "${value}".`);
+}
+function parseEntryTypes(values) {
+  return normalizeStringArray(values).map((value) => parseEntryType(value));
+}
+function parseEntryType(value) {
+  if (ENTRY_TYPES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported entry type "${value}".`);
+}
+function parseRecallMode(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (RECALL_MODES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported recall mode "${value}".`);
+}
+function normalizeStringArray(values) {
+  if (!values) {
+    return [];
+  }
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function formatTargetSelector(id, subject, last) {
+  if (last === true) {
+    return "last";
+  }
+  if (id) {
+    return `id:${JSON.stringify(id)}`;
+  }
+  if (subject) {
+    return `subject:${JSON.stringify(subject)}`;
+  }
+  return "unknown";
+}
+function formatTargetSelectorFromParams(params, options = {}) {
+  const id = readTrimmedOptionalStringParam(params, "id");
+  const subject = readTrimmedOptionalStringParam(params, "subject");
+  const last = options.allowLast ? readBooleanParam(params, "last") : void 0;
+  const maxValueChars = options.maxValueChars;
+  return formatTargetSelector(
+    id && maxValueChars !== void 0 ? truncate(id, maxValueChars) : id,
+    subject && maxValueChars !== void 0 ? truncate(subject, maxValueChars) : subject,
+    last
+  );
+}
+function readTrimmedOptionalStringParam(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string.`);
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function sanitizeUpdateToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {},
+    ...params.importance !== void 0 ? { importance: params.importance } : {},
+    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
+    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
+    ...params.validTo !== void 0 ? { hasValidTo: true } : {}
+  };
+}
+function sanitizeFetchToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {}
+  };
+}
+
 // src/app/episode-ingest/activity-threshold.ts
 function resolveEpisodeActivityEligibility(materialTurns, startedAt, endedAt, threshold) {
   const durationMs = resolveTranscriptDurationMs(startedAt, endedAt);
@@ -1172,8 +1333,8 @@ function detectClaimKeyEntityFamilyCandidates(entries) {
       return support?.autoSafe === true;
     });
     const componentProfiles = component.map((entity) => profiles.get(entity)).filter((profile) => Boolean(profile));
-    const entryIds = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.entryIds]));
-    const claimKeys = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.claimKeys]));
+    const entryIds = normalizeStringArray2(componentProfiles.flatMap((profile) => [...profile.entryIds]));
+    const claimKeys = normalizeStringArray2(componentProfiles.flatMap((profile) => [...profile.claimKeys]));
     const confidence = componentSupport.length > 0 ? Math.max(...componentSupport.map((support) => support.confidence)) : 0.75;
     families.push({
       entityPrefixes: [...component].sort((left, right) => left.localeCompare(right)),
@@ -1372,7 +1533,7 @@ function buildPairSupport(profiles) {
     }
   }
   for (const entities of attributeBuckets.values()) {
-    const normalizedEntities = normalizeStringArray(entities);
+    const normalizedEntities = normalizeStringArray2(entities);
     if (normalizedEntities.length < 2 || normalizedEntities.length > MAX_ATTRIBUTE_BUCKET_SIZE) {
       continue;
     }
@@ -1463,7 +1624,7 @@ function evaluateEntityFamilyPairSupport(leftProfile, rightProfile) {
   );
   return {
     entityPrefixes: [leftProfile.entityPrefix, rightProfile.entityPrefix],
-    supportingEntryIds: normalizeStringArray([...leftProfile.entryIds, ...rightProfile.entryIds]),
+    supportingEntryIds: normalizeStringArray2([...leftProfile.entryIds, ...rightProfile.entryIds]),
     sharedAttributes,
     confidence,
     autoSafe: lexicalRelation.autoSafe && (sharedAttributes.length >= 2 || sharedAttributes.length === 1 && groundingAnchorCount >= 1 && groundingScore >= 2),
@@ -1569,7 +1730,7 @@ function selectCanonicalEntityPrefix(entityPrefixes, pairSupport, profiles) {
       reasons.push(`lexical alias evidence prefers "${entityPrefix}"`);
     }
     scoreByEntity.set(entityPrefix, score);
-    reasonsByEntity.set(entityPrefix, normalizeStringArray(reasons));
+    reasonsByEntity.set(entityPrefix, normalizeStringArray2(reasons));
   }
   const ranked = [...scoreByEntity.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
   const [bestCandidate, secondCandidate] = ranked;
@@ -1813,7 +1974,7 @@ function intersectSets(left, right) {
   }
   return intersection.sort((first, second) => first.localeCompare(second));
 }
-function normalizeStringArray(values) {
+function normalizeStringArray2(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
 function buildPairKey(leftEntityPrefix, rightEntityPrefix) {
@@ -2078,7 +2239,7 @@ function evaluateClaimKeySupport(entry, targetClaimKey, trustedHints) {
     familyReuseCount: familyReuseEntries.length,
     groundedFamilyReuseCount: groundedFamilyReuseEntries.length,
     relaxedStableSlotFamilyGate: promotionSupport.relaxedStableSlotFamilyGate,
-    supportingEntryIds: normalizeStringArray2([
+    supportingEntryIds: normalizeStringArray3([
       ...groundedExactReuseEntries.map((candidate) => candidate.id),
       ...groundedFamilyReuseEntries.map((candidate) => candidate.id),
       ...familyReuseEntries.filter((candidate) => candidate.id.startsWith("example:")).map((candidate) => candidate.id)
@@ -2134,18 +2295,18 @@ function evaluateClaimKeyCompactness(claimKey, prior) {
   };
 }
 function normalizeGroundingTags(tags) {
-  return normalizeStringArray2((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
+  return normalizeStringArray3((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
 }
 function tokenizeGroundingText(value) {
   if (!value) {
     return [];
   }
-  return normalizeStringArray2(
+  return normalizeStringArray3(
     value.split(/[^a-zA-Z0-9]+/u).map((token) => normalizeClaimKeySegment(token)).filter((token) => token.length > 2 && !GROUNDING_STOP_TOKENS.has(token))
   );
 }
 function buildEntryLocalLexicalTokens(entry) {
-  return normalizeStringArray2([
+  return normalizeStringArray3([
     ...tokenizeGroundingText(entry.subject),
     ...tokenizeGroundingText(entry.content),
     ...tokenizeGroundingText(entry.source_context),
@@ -2253,7 +2414,7 @@ function intersects(left, right) {
   }
   return false;
 }
-function normalizeStringArray2(values) {
+function normalizeStringArray3(values) {
   const seen = /* @__PURE__ */ new Set();
   const normalized = [];
   for (const value of values) {
@@ -3891,6 +4052,24 @@ export {
   computeNormContentHash,
   validateEntriesWithIndexes,
   storeEntriesDetailed,
+  formatErrorMessage,
+  buildEntryMemoryResolverPorts,
+  resolveTargetEntry,
+  readBooleanParam,
+  ENTRY_TYPE_DESCRIPTION,
+  EXPIRY_DESCRIPTION,
+  UPDATE_EXPIRY_DESCRIPTION,
+  RECALL_MODES,
+  asRecord,
+  parseExpiry,
+  parseEntryTypes,
+  parseEntryType,
+  parseRecallMode,
+  normalizeStringArray,
+  formatTargetSelector,
+  formatTargetSelectorFromParams,
+  sanitizeUpdateToolParams,
+  sanitizeFetchToolParams,
   backfillEpisodeEmbeddings,
   prepareEpisodeIngest,
   ingestEpisodeTranscript,

package/dist/{chunk-TBFAARM5.js → chunk-JSVQILB3.js}

@@ -1,3 +1,7 @@
+import {
+  formatTargetSelectorFromParams
+} from "./chunk-EEEL53X4.js";
+
 // src/adapters/openclaw/transcript/parser.ts
 import { createHash } from "crypto";
 import * as fs2 from "fs/promises";
@@ -75,6 +79,7 @@ function parseJsonlLines(raw, onRecord) {
 }
 
 // src/adapters/openclaw/transcript/tool-summarization.ts
+var AGENR_FETCH_TARGET_MAX_CHARS = 80;
 var DEFAULT_TOOL_RESULT_DROP_NAMES = ["read", "web_fetch", "browser", "screenshot", "snapshot", "canvas", "tts"];
 var DEFAULT_TOOL_RESULT_KEEP_NAMES = ["web_search", "memory_search", "memory_get", "image"];
 var DEFAULT_TOOL_RESULT_DROP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_DROP_NAMES);
@@ -147,6 +152,9 @@ function toolIdentifier(toolName, args) {
     const query = getString(args.query) ?? "(no query)";
     return `"${truncateInline(query, 80)}"`;
   }
+  if (normalizedToolName === "agenr_fetch") {
+    return formatTargetSelectorFromParams(args, { maxValueChars: AGENR_FETCH_TARGET_MAX_CHARS });
+  }
   if (normalizedToolName === "message") {
     const action = getString(args.action) ?? "(unknown action)";
     const target = getString(args.target) ?? getString(args.to) ?? "(unknown target)";
@@ -247,6 +255,9 @@ function summarizeToolCall(call, options) {
     const query = getString(args.query) ?? "(no query)";
     return `[recalled from brain: "${truncateInline(query, 100)}"]`;
   }
+  if (normalizedToolName === "agenr_fetch") {
+    return `[fetched from brain: ${formatTargetSelectorFromParams(args, { maxValueChars: AGENR_FETCH_TARGET_MAX_CHARS })}]`;
+  }
   if (normalizedToolName === "sessions_spawn") {
     const label = getString(args.label);
     const mode = getString(args.mode) ?? "run";
@@ -550,7 +561,7 @@ async function applyMessageTimestampFallbacks(filePath, messages, options) {
 // src/adapters/openclaw/transcript/parser.ts
 var SKIPPED_RECORD_TYPES = /* @__PURE__ */ new Set(["compaction", "custom", "thinking_level_change"]);
 var TOOL_RESULT_POLICY = {
-  dropToolNames: /* @__PURE__ */ new Set([...DEFAULT_TOOL_RESULT_DROP_NAMES, "agenr_recall", "image"]),
+  dropToolNames: /* @__PURE__ */ new Set([...DEFAULT_TOOL_RESULT_DROP_NAMES, "agenr_recall", "agenr_fetch", "image"]),
   keepToolNames: new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES.filter((name) => name !== "image"))
 };
 var RAW_TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);

package/dist/{chunk-ELR2HSVC.js → chunk-NNO2V4GH.js}

@@ -5399,6 +5399,236 @@ async function rollbackTransaction(transaction) {
   await transaction.rollback();
 }
 
+// src/adapters/shared/memory-tool-format.ts
+var DEFAULT_RECALL_LIMIT = 10;
+var RESULT_SUBJECT_LOG_LIMIT = 5;
+var ENTRY_PREVIEW_MAX_CHARS = 220;
+var ENTRY_FETCH_MAX_CONTENT_CHARS = 32768;
+function buildEntryRecallPreview(content) {
+  const trimmed = content.trim();
+  const previewTruncated = trimmed.length > ENTRY_PREVIEW_MAX_CHARS;
+  return {
+    contentPreview: previewTruncated ? truncate(trimmed, ENTRY_PREVIEW_MAX_CHARS) : trimmed,
+    contentChars: trimmed.length,
+    previewTruncated
+  };
+}
+function recallResultHasTruncatedEntryPreviews(result) {
+  if (result.entries.some((entry) => buildEntryRecallPreview(entry.entry.content).previewTruncated)) {
+    return true;
+  }
+  return result.entryFamilies.some((family) => family.entries.some((entry) => buildEntryRecallPreview(entry.recall.entry.content).previewTruncated));
+}
+function assertEntryFetchableContentLength(content) {
+  const contentChars = content.trim().length;
+  if (contentChars > ENTRY_FETCH_MAX_CONTENT_CHARS) {
+    throw new Error(
+      `Entry content is ${contentChars} characters, which exceeds the agenr_fetch limit of ${ENTRY_FETCH_MAX_CONTENT_CHARS}. Use agenr_trace or the CLI for full inspection.`
+    );
+  }
+}
+function truncate(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
+}
+function sanitizeStoreToolParams(params) {
+  return {
+    type: params.type,
+    subject: params.subject,
+    ...params.importance !== void 0 ? { importance: params.importance } : {},
+    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+    ...params.tags.length > 0 ? { tags: params.tags } : {},
+    contentLength: params.content.length,
+    ...params.sourceContext !== void 0 ? { sourceContextLength: params.sourceContext.length } : {},
+    ...params.supersedes !== void 0 ? { hasSupersedes: true } : {},
+    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
+    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
+    ...params.validTo !== void 0 ? { hasValidTo: true } : {}
+  };
+}
+function formatRecallToolSummary(params) {
+  const parts = [`query=${JSON.stringify(truncate(params.query, 80))}`];
+  if (params.mode) {
+    parts.push(`mode=${params.mode}`);
+  }
+  if (params.limit !== void 0 && params.limit !== DEFAULT_RECALL_LIMIT) {
+    parts.push(`limit=${params.limit}`);
+  }
+  if (params.types.length > 0) {
+    parts.push(`types=${JSON.stringify(params.types)}`);
+  }
+  if (params.tags.length > 0) {
+    parts.push(`tags=${JSON.stringify(params.tags)}`);
+  }
+  if (params.asOf) {
+    parts.push(`as_of=${JSON.stringify(params.asOf)}`);
+  }
+  if (params.budget !== void 0) {
+    parts.push(`budget=${params.budget}`);
+  }
+  return parts.join(" ");
+}
+function sanitizeRecallToolParams(params) {
+  return {
+    query: params.query,
+    ...params.mode ? { mode: params.mode } : {},
+    ...params.limit !== void 0 ? { limit: params.limit } : {},
+    ...params.threshold !== void 0 ? { threshold: params.threshold } : {},
+    ...params.types.length > 0 ? { types: params.types } : {},
+    ...params.tags.length > 0 ? { tags: params.tags } : {},
+    ...params.asOf ? { asOf: params.asOf } : {},
+    ...params.budget !== void 0 ? { budget: params.budget } : {}
+  };
+}
+function formatUnifiedRecallLogSummary(result) {
+  const procedureCount = result.procedureCandidates.length;
+  const procedureSummary = result.procedure ? ` [procedure: ${JSON.stringify(truncate(result.procedure.title, 80))}]` : "";
+  const entrySubjects = result.entries.map((entry) => entry.entry.subject.trim()).filter((subject) => subject.length > 0);
+  const displayed = entrySubjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
+  const remaining = entrySubjects.length - RESULT_SUBJECT_LOG_LIMIT;
+  const suffix = displayed.length === 0 ? "" : ` [entry subjects: ${displayed.join(", ")}${remaining > 0 ? `, ... and ${remaining} more` : ""}]`;
+  const entryEpisodeSummary = `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}`;
+  if (procedureCount === 0 && !result.procedure) {
+    return `${entryEpisodeSummary}${suffix}`;
+  }
+  return `${procedureCount} procedure candidate${procedureCount === 1 ? "" : "s"}, ${entryEpisodeSummary}${procedureSummary}${suffix}`;
+}
+function buildRecallToolDetails(result, extraDetails = {}) {
+  return {
+    status: "ok",
+    count: result.count,
+    ...extraDetails,
+    routing: {
+      requested: result.routing.requested,
+      detectedIntent: result.routing.detectedIntent,
+      queried: result.routing.queried,
+      reason: result.routing.reason
+    },
+    ...result.asOf ? { asOf: result.asOf } : {},
+    ...result.timeWindow ? { timeWindow: result.timeWindow } : {},
+    ...result.procedure ? {
+      procedure: {
+        id: result.procedure.id,
+        procedureKey: result.procedure.procedure_key,
+        title: result.procedure.title,
+        goal: result.procedure.goal
+      }
+    } : {},
+    procedures: result.procedureCandidates.map((candidate) => ({
+      id: candidate.procedure.id,
+      procedureKey: candidate.procedure.procedure_key,
+      title: candidate.procedure.title,
+      goal: candidate.procedure.goal,
+      score: candidate.score,
+      lexicalScore: candidate.scores.lexical,
+      vectorScore: candidate.scores.vector
+    })),
+    procedureNotices: result.procedureNotices,
+    episodes: result.episodes.map((episode) => ({
+      id: episode.episode.id,
+      source: episode.episode.source,
+      sourceId: episode.episode.sourceId,
+      startedAt: episode.episode.startedAt,
+      endedAt: episode.episode.endedAt,
+      tags: episode.episode.tags,
+      score: episode.score,
+      activityLevel: episode.episode.activityLevel,
+      summary: episode.episode.summary,
+      whyMatched: describeEpisodeWhyMatched(episode.scores.semantic, episode.scores.temporal)
+    })),
+    entries: result.entries.map((entry) => {
+      const preview = buildEntryRecallPreview(entry.entry.content);
+      return {
+        id: entry.entry.id,
+        subject: entry.entry.subject,
+        type: entry.entry.type,
+        expiry: entry.entry.expiry,
+        importance: entry.entry.importance,
+        score: entry.score,
+        tags: entry.entry.tags,
+        contentPreview: preview.contentPreview,
+        contentChars: preview.contentChars,
+        previewTruncated: preview.previewTruncated
+      };
+    }),
+    projectedEntries: result.projectedEntries.map((entry) => {
+      const preview = buildEntryRecallPreview(entry.recall.entry.content);
+      return {
+        id: entry.entryId,
+        familyKey: entry.familyKey,
+        claimKey: entry.claimKey,
+        slotPolicy: entry.slotPolicy,
+        memoryState: entry.memoryState,
+        claimStatus: entry.claimStatus,
+        freshness: entry.freshness,
+        provenance: entry.provenance,
+        whySurfaced: entry.whySurfaced,
+        contentPreview: preview.contentPreview,
+        contentChars: preview.contentChars,
+        previewTruncated: preview.previewTruncated
+      };
+    }),
+    entryFamilies: result.entryFamilies.map((family) => ({
+      familyKey: family.familyKey,
+      claimKey: family.claimKey,
+      slotPolicy: family.slotPolicy,
+      subject: family.subject,
+      primaryEntryId: family.primary.entryId,
+      entries: family.entries.map((entry) => ({
+        id: entry.entryId,
+        memoryState: entry.memoryState,
+        claimStatus: entry.claimStatus
+      }))
+    })),
+    claimTransitions: result.claimTransitions,
+    notices: result.notices
+  };
+}
+function formatFetchedEntryText(entry) {
+  const metadata = [
+    `Entry ${entry.id}`,
+    `subject=${entry.subject}`,
+    `type=${entry.type} importance=${entry.importance} expiry=${entry.expiry} created=${entry.created_at}`,
+    entry.claim_key ? `claim_key=${entry.claim_key}` : void 0,
+    entry.tags.length > 0 ? `tags=${entry.tags.join(", ")}` : void 0,
+    entry.valid_from ? `valid_from=${entry.valid_from}` : void 0,
+    entry.valid_to ? `valid_to=${entry.valid_to}` : void 0,
+    entry.source_context ? `source_context=${entry.source_context}` : void 0
+  ].filter((value) => value !== void 0);
+  return [...metadata, "", entry.content.trim()].join("\n");
+}
+function buildFetchToolDetails(entry, extraDetails = {}) {
+  return {
+    status: "ok",
+    entryId: entry.id,
+    subject: entry.subject,
+    type: entry.type,
+    importance: entry.importance,
+    expiry: entry.expiry,
+    tags: entry.tags,
+    ...entry.claim_key ? { claimKey: entry.claim_key } : {},
+    ...entry.valid_from ? { validFrom: entry.valid_from } : {},
+    ...entry.valid_to ? { validTo: entry.valid_to } : {},
+    ...entry.source_context ? { sourceContext: entry.source_context } : {},
+    content: entry.content,
+    ...extraDetails
+  };
+}
+function describeEpisodeWhyMatched(semanticScore, temporalScore) {
+  if (semanticScore > 0 && temporalScore > 0) {
+    return "Semantic match within the resolved time window.";
+  }
+  if (semanticScore > 0) {
+    return "Semantic match to the episode summary.";
+  }
+  if (temporalScore > 0) {
+    return "Session overlaps the resolved time window.";
+  }
+  return "Matched episodic recall ranking.";
+}
+
 // src/adapters/db/recall-adapter.ts
 var RECALL_CANDIDATE_SELECT_COLUMNS = `
   e.id,
@@ -7515,6 +7745,7 @@ function buildEntryRecallInput(input, parsedTimeWindow, routing) {
     text: input.text,
     ...input.limit !== void 0 ? { limit: input.limit } : {},
     ...input.threshold !== void 0 ? { threshold: input.threshold } : {},
+    ...input.budget !== void 0 ? { budget: input.budget } : {},
     ...input.types && input.types.length > 0 ? { types: input.types } : {},
     ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
     ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
@@ -7764,6 +7995,18 @@ export {
   resolveModel,
   resolveLlmCredentials,
   resolveLlmApiKey,
+  ENTRY_PREVIEW_MAX_CHARS,
+  buildEntryRecallPreview,
+  recallResultHasTruncatedEntryPreviews,
+  assertEntryFetchableContentLength,
+  truncate,
+  sanitizeStoreToolParams,
+  formatRecallToolSummary,
+  sanitizeRecallToolParams,
+  formatUnifiedRecallLogSummary,
+  buildRecallToolDetails,
+  formatFetchedEntryText,
+  buildFetchToolDetails,
   createOpenAICrossEncoder,
   resolveCrossEncoderApiKey,
   createRecallAdapter,

package/dist/{chunk-P5SB75FK.js → chunk-NOIZQRQV.js}

@@ -12,7 +12,7 @@ import {
 import {
   formatAgenrBeforeTurnRecall,
   runBeforeTurn
-} from "./chunk-575MUIW5.js";
+} from "./chunk-V5CDMHRN.js";
 import {
   CLAIM_KEY_SOURCES,
   CLAIM_KEY_STATUSES,
@@ -41,7 +41,7 @@ import {
   resolveEmbeddingModel,
   resolveModel,
   runUnifiedRecall
-} from "./chunk-ELR2HSVC.js";
+} from "./chunk-NNO2V4GH.js";
 import {
   recall
 } from "./chunk-5LADPJ4C.js";