agenr 3.0.0 → 3.2.0

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

@@ -21,8 +21,9 @@ import {
   readNumber,
   readOptionalString,
   readRequiredString,
+  truncate,
   validateTemporalValidityRange
-} from "./chunk-ELR2HSVC.js";
+} from "./chunk-FMQTRTWE.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-575MUIW5.js → chunk-UEGURBBW.js}

@@ -1,7 +1,8 @@
 import {
   projectClaimCentricRecallEntry,
-  runProcedureRecall
-} from "./chunk-ELR2HSVC.js";
+  runProcedureRecall,
+  truncate
+} from "./chunk-FMQTRTWE.js";
 import {
   recall
 } from "./chunk-5LADPJ4C.js";
@@ -355,7 +356,7 @@ function buildCurrentTurnOnlyQuery(currentTurnText, maxChars) {
   if (maxChars <= 0) {
     return void 0;
   }
-  const query = truncate(normalizeWhitespace(currentTurnText), maxChars);
+  const query = truncate2(normalizeWhitespace(currentTurnText), maxChars);
   return query.length > 0 ? query : void 0;
 }
 function buildContextualAnchorQuery(currentTurnQuery, recentTurns, maxChars) {
@@ -369,7 +370,7 @@ function buildContextualAnchorQuery(currentTurnQuery, recentTurns, maxChars) {
   if (remaining <= 0) {
     return void 0;
   }
-  return `${currentTurnQuery}${separator}${prefix}${truncate(anchor, remaining)}`;
+  return `${currentTurnQuery}${separator}${prefix}${truncate2(anchor, remaining)}`;
 }
 function buildCompactContextAnchor(recentTurns) {
   const recentTurn = recentTurns[recentTurns.length - 1];
@@ -377,7 +378,7 @@ function buildCompactContextAnchor(recentTurns) {
     return void 0;
   }
   const normalized = normalizeWhitespace(recentTurn.text);
-  return normalized.length > 0 ? truncate(normalized, MAX_CONTEXT_ANCHOR_CHARS) : void 0;
+  return normalized.length > 0 ? truncate2(normalized, MAX_CONTEXT_ANCHOR_CHARS) : void 0;
 }
 function requiresContextualQuery(currentTurnText) {
   const normalizedTurn = normalizeWhitespace(currentTurnText);
@@ -401,10 +402,10 @@ function shouldAllowContextualFallback(currentTurnText, recentTurns) {
 function buildProcedureQuery(currentTurnText, recentTurns, maxChars) {
   const normalizedCurrentTurn = normalizeWhitespace(currentTurnText);
   if (normalizedCurrentTurn.length > 0) {
-    return truncate(normalizedCurrentTurn, maxChars);
+    return truncate2(normalizedCurrentTurn, maxChars);
   }
   const recentUserTurn = [...recentTurns].reverse().find((turn) => turn.role === "user");
-  return recentUserTurn ? truncate(normalizeWhitespace(recentUserTurn.text), maxChars) : void 0;
+  return recentUserTurn ? truncate2(normalizeWhitespace(recentUserTurn.text), maxChars) : void 0;
 }
 function applyDirectnessSelection(currentTurnText, items) {
   if (items.length === 0) {
@@ -748,7 +749,7 @@ function normalizeOptionalString(value) {
 function normalizeWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
 }
-function truncate(value, maxChars) {
+function truncate2(value, maxChars) {
   if (maxChars <= 0) {
     return "";
   }
@@ -764,166 +765,6 @@ function formatErrorMessage(error) {
   return String(error);
 }
 
-// src/adapters/shared/memory-tool-format.ts
-var DEFAULT_RECALL_LIMIT = 10;
-var RESULT_SUBJECT_LOG_LIMIT = 5;
-function truncate2(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(truncate2(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)}`);
-  }
-  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 } : {}
-  };
-}
-function formatUnifiedRecallLogSummary(result) {
-  const procedureCount = result.procedureCandidates.length;
-  const procedureSummary = result.procedure ? ` [procedure: ${JSON.stringify(truncate2(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(truncate2(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) => ({
-      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,
-      content: entry.entry.content
-    })),
-    projectedEntries: result.projectedEntries.map((entry) => ({
-      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
-    })),
-    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 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/shared/injection/entry-lines.ts
 var MAX_CONTENT_CHARS = 220;
 function formatInjectionEntryHeader(item) {
@@ -938,12 +779,12 @@ function formatInjectionEntryHeader(item) {
   return `- [${metadata.join(" | ")}] ${item.entry.subject}`;
 }
 function formatInjectionEntryBodyLines(item) {
-  const lines = [`  ${truncate2(item.entry.content.trim(), MAX_CONTENT_CHARS)}`];
+  const lines = [`  ${truncate(item.entry.content.trim(), MAX_CONTENT_CHARS)}`];
   lines.push(`  why: ${item.whySurfaced.summary}`);
   const metadata = [
     item.entry.tags.length > 0 ? `tags: ${item.entry.tags.join(", ")}` : void 0,
     item.freshnessLabel ? `freshness: ${item.freshnessLabel}` : void 0,
-    item.provenanceSummary ? `provenance: ${truncate2(item.provenanceSummary, MAX_CONTENT_CHARS)}` : void 0
+    item.provenanceSummary ? `provenance: ${truncate(item.provenanceSummary, MAX_CONTENT_CHARS)}` : void 0
   ].filter((value) => value !== void 0);
   if (metadata.length > 0) {
     lines.push(`  ${metadata.join(" | ")}`);
@@ -1011,25 +852,19 @@ function formatProcedureHeader(suggestion) {
   return `- [${metadata.join(" | ")}] ${suggestion.procedure.title}`;
 }
 function formatProcedureBodyLines(suggestion) {
-  const lines = [`  goal: ${truncate2(suggestion.procedure.goal.trim(), MAX_CONTENT_CHARS2)}`];
+  const lines = [`  goal: ${truncate(suggestion.procedure.goal.trim(), MAX_CONTENT_CHARS2)}`];
   lines.push(`  why: ${suggestion.whySurfaced.summary}`);
   if (suggestion.procedure.when_to_use.length > 0) {
-    lines.push(`  when to use: ${truncate2(suggestion.procedure.when_to_use.join("; "), MAX_CONTENT_CHARS2)}`);
+    lines.push(`  when to use: ${truncate(suggestion.procedure.when_to_use.join("; "), MAX_CONTENT_CHARS2)}`);
   }
   if (suggestion.procedure.verification.length > 0) {
-    lines.push(`  verification: ${truncate2(suggestion.procedure.verification.join("; "), MAX_CONTENT_CHARS2)}`);
+    lines.push(`  verification: ${truncate(suggestion.procedure.verification.join("; "), MAX_CONTENT_CHARS2)}`);
   }
   return lines;
 }
 
 export {
   runBeforeTurn,
-  truncate2 as truncate,
-  sanitizeStoreToolParams,
-  formatRecallToolSummary,
-  sanitizeRecallToolParams,
-  formatUnifiedRecallLogSummary,
-  buildRecallToolDetails,
   formatInjectionEntryHeader,
   formatInjectionEntryBodyLines,
   wrapAgenrMemoryContext,

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

@@ -1,3 +1,7 @@
+import {
+  formatTargetSelectorFromParams
+} from "./chunk-TMDNFBBC.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"]);