@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/{chunk-KH52KJSJ.js → chunk-XFJ4S4G2.js}

@@ -1,11 +1,344 @@
 import {
+  DURABLE_SELECT_COLUMNS,
+  buildActiveDurableClause,
+  buildValidAsOfClause,
+  getDurables,
+  mapDurableRow,
+  parseJsonStringArray,
   projectClaimCentricRecallEntry,
+  readOptionalString,
+  readRequiredString,
   runProcedureRecall,
   truncate
-} from "./chunk-Z5X7T4QZ.js";
+} from "./chunk-5TIP2EPP.js";
 import {
   recall
-} from "./chunk-5LADPJ4C.js";
+} from "./chunk-GAERET5Q.js";
+import {
+  MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX,
+  isDirectiveDurable,
+  isProactiveDirectiveDurable,
+  parseDirectiveMetadata
+} from "./chunk-VTHBPXDQ.js";
+import {
+  isCurrentlyValidMemory,
+  isWithinValidityWindow,
+  resolveKeyedDurableLifecycleStatus
+} from "./chunk-VBPYU7GO.js";
+
+// src/core/directives/abstain.ts
+var ABSTAIN_VERB_PATTERN = "(?:mention|mentioning|bring up|bringing up|discuss|discussing|talk about|talking about|reference|referencing|raise|raising|recommend|recommending|suggest|suggesting|surface|surfacing|remind me about|remind me of)";
+var ABSTAIN_LEAD_PATTERN = "(?:do not|don't|do n't|never|please do not|please don't|stop|avoid|no longer)";
+var ABSTAIN_PHRASE_PATTERN = new RegExp(`\\b${ABSTAIN_LEAD_PATTERN}\\s+${ABSTAIN_VERB_PATTERN}\\s+(.+?)(?:[.!?;]|$)`, "giu");
+var TRAILING_QUALIFIER_PATTERN = /\b(?:again|anymore|any more|ever again|ever|at all|please|with me|to me)\s*$/giu;
+var LEADING_DETERMINER_PATTERN = /^(?:the|a|an|any|my|our|that|this|these|those)\s+/iu;
+var MIN_BLOCKED_TERM_LENGTH = 2;
+function parseAbstainDirective(entry) {
+  const metadata = parseDirectiveMetadata(entry);
+  if (!metadata || metadata.polarity !== "abstain") {
+    return null;
+  }
+  const claimKey = entry.claim_key?.trim() ?? `${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX}${entry.id}`;
+  const blockedTerms = extractBlockedTerms(entry, claimKey);
+  if (blockedTerms.length === 0) {
+    return null;
+  }
+  return {
+    id: entry.id,
+    claimKey,
+    blockedTerms
+  };
+}
+function collectAbstainDirectives(entries) {
+  const directives = [];
+  for (const entry of entries) {
+    const directive = parseAbstainDirective(entry);
+    if (directive) {
+      directives.push(directive);
+    }
+  }
+  return directives;
+}
+function findAbstainViolation(entry, directives) {
+  if (directives.length === 0) {
+    return null;
+  }
+  const haystack = normalizeForMatch(`${entry.subject} ${entry.content}`);
+  if (haystack.length === 0) {
+    return null;
+  }
+  for (const directive of directives) {
+    if (directive.id === entry.id) {
+      continue;
+    }
+    for (const blockedTerm of directive.blockedTerms) {
+      if (mentionsBlockedTerm(haystack, blockedTerm)) {
+        return {
+          directiveId: directive.id,
+          blockedTerm
+        };
+      }
+    }
+  }
+  return null;
+}
+function normalizeTextForPhraseMatch(value) {
+  return normalizeForMatch(value);
+}
+function textMentionsPhrase(normalizedHaystack, normalizedPhrase) {
+  return mentionsBlockedTerm(normalizedHaystack, normalizedPhrase);
+}
+function textMatchesTopicTrigger(normalizedHaystack, trigger) {
+  if (!trigger.startsWith("topic:")) {
+    return false;
+  }
+  const topic = trigger.slice("topic:".length);
+  return textMentionsPhrase(normalizedHaystack, topic);
+}
+function extractBlockedTerms(entry, claimKey) {
+  const terms = /* @__PURE__ */ new Set();
+  for (const source of [entry.content, entry.subject]) {
+    for (const phrase of matchAbstainPhrases(source)) {
+      const cleaned = cleanBlockedTerm(phrase);
+      if (cleaned.length >= MIN_BLOCKED_TERM_LENGTH) {
+        terms.add(cleaned);
+      }
+    }
+  }
+  if (terms.size === 0) {
+    const fallback = cleanBlockedTerm(deriveTermFromClaimKey(claimKey));
+    if (fallback.length >= MIN_BLOCKED_TERM_LENGTH) {
+      terms.add(fallback);
+    }
+  }
+  return Array.from(terms);
+}
+function matchAbstainPhrases(source) {
+  const phrases = [];
+  const pattern = new RegExp(ABSTAIN_PHRASE_PATTERN.source, ABSTAIN_PHRASE_PATTERN.flags);
+  let match = pattern.exec(source);
+  while (match !== null) {
+    const captured = match[1];
+    if (captured) {
+      phrases.push(captured);
+    }
+    match = pattern.exec(source);
+  }
+  return phrases;
+}
+function deriveTermFromClaimKey(claimKey) {
+  const suffix = claimKey.slice(MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX.length);
+  return suffix.replace(/^(?:do[_-]?not[_-]?mention[_-]?|avoid[_-]?|no[_-]?)/iu, "").replace(/[_-]+/gu, " ").trim();
+}
+function cleanBlockedTerm(phrase) {
+  const collapsed = phrase.replace(/\s+/gu, " ").trim();
+  const withoutLead = collapsed.replace(LEADING_DETERMINER_PATTERN, "");
+  const withoutTrailing = withoutLead.replace(TRAILING_QUALIFIER_PATTERN, "").trim();
+  return normalizeForMatch(withoutTrailing);
+}
+function mentionsBlockedTerm(haystack, blockedTerm) {
+  if (blockedTerm.length < MIN_BLOCKED_TERM_LENGTH) {
+    return false;
+  }
+  const escaped = escapeRegExp(blockedTerm).replace(/\\?\s+/gu, "\\s+");
+  const pattern = new RegExp(`(?:^|[^\\p{L}\\p{N}])${escaped}(?:[^\\p{L}\\p{N}]|$)`, "iu");
+  return pattern.test(haystack);
+}
+function normalizeForMatch(value) {
+  return value.replace(/\s+/gu, " ").trim().normalize("NFKC").toLocaleLowerCase();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
+// src/app/directives/abstain-filter.ts
+var ABSTAIN_DIRECTIVE_LOOKUP_FAILED_NOTICE = "Memory-directive lookup failed; blocked-topic suppression was skipped this pass and only directive rows were withheld.";
+async function applyAbstainDirectives(items, listActiveAbstainDirectives2) {
+  if (items.length === 0) {
+    return { kept: [...items], suppressed: [], lookupFailed: false };
+  }
+  const suppressed = [];
+  const nonDirectiveItems = [];
+  for (const item of items) {
+    if (isDirectiveDurable(item.entry) && !isAllowedDirectiveInjectionItem(item)) {
+      suppressed.push({ entryId: item.entry.id, reason: "directive_self" });
+      continue;
+    }
+    nonDirectiveItems.push(item);
+  }
+  if (!listActiveAbstainDirectives2 || nonDirectiveItems.length === 0) {
+    return { kept: nonDirectiveItems, suppressed, lookupFailed: false };
+  }
+  let directiveRows;
+  try {
+    directiveRows = await listActiveAbstainDirectives2();
+  } catch {
+    return { kept: nonDirectiveItems, suppressed, lookupFailed: true };
+  }
+  const directives = collectAbstainDirectives(directiveRows);
+  if (directives.length === 0) {
+    return { kept: nonDirectiveItems, suppressed, lookupFailed: false };
+  }
+  const kept = [];
+  for (const item of nonDirectiveItems) {
+    const violation = findAbstainViolation(item.entry, directives);
+    if (violation) {
+      suppressed.push({
+        entryId: item.entry.id,
+        reason: "directive_topic",
+        directiveId: violation.directiveId,
+        blockedTerm: violation.blockedTerm
+      });
+      continue;
+    }
+    kept.push(item);
+  }
+  return { kept, suppressed, lookupFailed: false };
+}
+function buildAbstentionNotice(suppression) {
+  if (suppression.reason === "directive_self") {
+    return `Skipped injecting memory directive ${suppression.entryId}; directives are not surfaced as memory.`;
+  }
+  const directive = suppression.directiveId ?? "unknown";
+  const term = suppression.blockedTerm ?? "a blocked topic";
+  return `Suppressed durable ${suppression.entryId} because memory directive ${directive} blocks "${term}".`;
+}
+async function applyAbstainDirectivesForInjection(items, listActiveAbstainDirectives2, diagnostics) {
+  const result = await applyAbstainDirectives(items, listActiveAbstainDirectives2);
+  if (result.lookupFailed) {
+    diagnostics.notices.push(ABSTAIN_DIRECTIVE_LOOKUP_FAILED_NOTICE);
+  }
+  if (result.suppressed.length > 0) {
+    diagnostics.directiveAbstentions = result.suppressed;
+    for (const suppression of result.suppressed) {
+      diagnostics.notices.push(buildAbstentionNotice(suppression));
+    }
+  }
+  return result.kept;
+}
+function isAllowedDirectiveInjectionItem(item) {
+  return item.sourceKind === "directive" && isProactiveDirectiveDurable(item.entry);
+}
+
+// src/app/before-turn/format-provenance.ts
+function formatProjectedProvenance(provenance) {
+  const parts = [
+    provenance.supersededById ? `superseded_by=${provenance.supersededById}` : void 0,
+    provenance.supersessionKind ? `kind=${provenance.supersessionKind}` : void 0,
+    provenance.supersessionReason ? `reason=${provenance.supersessionReason}` : void 0,
+    provenance.supportSourceKind ? `support=${provenance.supportSourceKind}` : void 0,
+    provenance.supportMode ? `support_mode=${provenance.supportMode}` : void 0,
+    provenance.supportObservedAt ? `observed=${provenance.supportObservedAt}` : void 0,
+    provenance.supportLocator ? `locator=${provenance.supportLocator}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+
+// src/app/before-turn/select-patch-items.ts
+function selectDurablePatchItems(items, policy, diagnostics) {
+  if (policy.maxDurableEntries <= 0 || items.length === 0) {
+    return [];
+  }
+  const boundedItems = items.slice(0, policy.maxDurableEntries);
+  const expandedLimit = Math.max(policy.maxDurableEntries, policy.maxHighConfidenceDurableEntries);
+  if (expandedLimit <= policy.maxDurableEntries || items.length <= policy.maxDurableEntries) {
+    return boundedItems;
+  }
+  const expansionCandidates = items.slice(0, expandedLimit);
+  const canExpand = expansionCandidates.length > policy.maxDurableEntries && expansionCandidates.every((item) => item.score >= policy.highConfidenceRecallThreshold);
+  if (canExpand) {
+    diagnostics.notices.push(`Before-turn durable recall expanded to ${expansionCandidates.length} high-confidence items.`);
+    return expansionCandidates;
+  }
+  diagnostics.notices.push(
+    `Before-turn durable recall kept the top ${boundedItems.length} item${boundedItems.length === 1 ? "" : "s"} because additional candidates were not high confidence.`
+  );
+  return boundedItems;
+}
+
+// src/app/before-turn/topic-directives.ts
+var TOPIC_PROACTIVE_DIRECTIVE_LOOKUP_FAILED_NOTICE = "Topic proactive directive lookup failed; topic directive surfacing was skipped this pass.";
+async function injectTopicProactiveDirectives(currentTurnText, recalledItems, policy, deps, diagnostics) {
+  if (!deps.listActiveTopicProactiveDirectives) {
+    return recalledItems;
+  }
+  let directiveRows;
+  try {
+    directiveRows = await deps.listActiveTopicProactiveDirectives();
+  } catch {
+    diagnostics.notices.push(TOPIC_PROACTIVE_DIRECTIVE_LOOKUP_FAILED_NOTICE);
+    return recalledItems;
+  }
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const activeDirectives = filterCurrentEntries(directiveRows, nowMs);
+  diagnostics.topicProactiveDirectiveCandidateCount = activeDirectives.length;
+  const normalizedTurn = normalizeTextForPhraseMatch(currentTurnText);
+  const matchedDirectives = activeDirectives.filter((entry) => {
+    const metadata = parseDirectiveMetadata(entry);
+    return metadata?.polarity === "proactive" && metadata.trigger.startsWith("topic:") && textMatchesTopicTrigger(normalizedTurn, metadata.trigger);
+  });
+  diagnostics.topicProactiveDirectiveMatchedCount = matchedDirectives.length;
+  if (matchedDirectives.length === 0) {
+    return recalledItems;
+  }
+  const directiveItems = matchedDirectives.map((entry) => buildTopicDirectivePatchItem(entry, deps, policy.highConfidenceRecallThreshold));
+  return mergeTopicDirectivePatchItems(directiveItems, recalledItems, policy, diagnostics);
+}
+function filterCurrentEntries(entries, nowMs) {
+  return entries.filter((entry) => isWithinValidityWindow(entry.valid_from, entry.valid_to, nowMs));
+}
+function buildTopicDirectivePatchItem(entry, deps, score) {
+  const metadata = parseDirectiveMetadata(entry);
+  const projected = projectClaimCentricRecallEntry(buildSyntheticRecallOutput(entry, score), {
+    slotPolicyConfig: deps.slotPolicyConfig
+  });
+  const provenanceSummary = formatProjectedProvenance(projected.provenance);
+  return {
+    rank: 0,
+    entry,
+    sourceKind: "directive",
+    score,
+    whySurfaced: {
+      summary: `proactive memory directive; trigger ${metadata?.trigger ?? "topic"}`,
+      reasons: ["proactive memory directive", `trigger ${metadata?.trigger ?? "topic"}`, `importance ${entry.importance}`]
+    },
+    memoryState: projected.memoryState,
+    claimStatus: projected.claimStatus,
+    freshnessLabel: projected.freshness.label,
+    ...provenanceSummary ? { provenanceSummary } : {}
+  };
+}
+function buildSyntheticRecallOutput(entry, score) {
+  return {
+    entry,
+    score,
+    scores: {
+      relevance: score,
+      rrf: score,
+      vector: 0,
+      lexical: 0,
+      recency: 1,
+      importance: entry.importance / 10,
+      historicalLineage: 0,
+      neighborhoodBoost: 0,
+      claimKeyTrustPenalty: 0,
+      claimKeyRedundancyPenalty: 0
+    }
+  };
+}
+function mergeTopicDirectivePatchItems(directiveItems, recalledItems, policy, diagnostics) {
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const item of [...directiveItems, ...recalledItems]) {
+    if (seenEntryIds.has(item.entry.id)) {
+      continue;
+    }
+    seenEntryIds.add(item.entry.id);
+    merged.push(item);
+  }
+  return selectDurablePatchItems(merged, policy, diagnostics);
+}
 
 // src/app/before-turn/service.ts
 var DEFAULT_MAX_DURABLE_ENTRIES = 1;
@@ -114,10 +447,12 @@ async function runBeforeTurn(input, deps) {
       diagnostics
     };
   }
-  const [durableMemory, procedure] = await Promise.all([
+  const [recalledDurableMemory, procedure] = await Promise.all([
     policy.enableDurableRecall ? runDurableRecallSelection(currentTurnText, durableQueryPlan, input.sessionKey, policy, deps, diagnostics) : Promise.resolve([]),
     policy.enableProcedureSuggestion && procedureQuery ? runProcedureSelection(procedureQuery, policy, deps, diagnostics) : Promise.resolve(void 0)
   ]);
+  const durableMemoryWithTopicDirectives = await injectTopicProactiveDirectives(currentTurnText, recalledDurableMemory, policy, deps, diagnostics);
+  const durableMemory = await applyAbstainDirectivesForInjection(durableMemoryWithTopicDirectives, deps.listActiveAbstainDirectives, diagnostics);
   if (!policy.enableDurableRecall) {
     diagnostics.abstentionReasons.push("Durable recall disabled by before-turn policy.");
   } else if (durableMemory.length === 0) {
@@ -217,7 +552,8 @@ async function runDurableRecallAttempt(currentTurnText, query, sessionKey, polic
             durableRecallTrace = summary;
           }
         },
-        slotPolicyConfig: deps.slotPolicyConfig
+        slotPolicyConfig: deps.slotPolicyConfig,
+        ...deps.now ? { now: deps.now } : {}
       }
     );
     const notices = durableRecallTrace?.degraded.notices.length ? [...durableRecallTrace.degraded.notices] : [];
@@ -537,7 +873,7 @@ function isIdentityWrapperSubject(subject, entity) {
   return false;
 }
 function hasDefinitionalContent(content, entity) {
-  const escapedEntity = escapeRegExp(entity);
+  const escapedEntity = escapeRegExp2(entity);
   if (startsWithBareRelationshipPredicate(content, escapedEntity)) {
     return false;
   }
@@ -602,32 +938,12 @@ function containsKeyword(text, keywords) {
   }
   return false;
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function roundToThreeDecimals(value) {
   return Math.round(value * 1e3) / 1e3;
 }
-function selectDurablePatchItems(items, policy, diagnostics) {
-  if (policy.maxDurableEntries <= 0 || items.length === 0) {
-    return [];
-  }
-  const boundedItems = items.slice(0, policy.maxDurableEntries);
-  const expandedLimit = Math.max(policy.maxDurableEntries, policy.maxHighConfidenceDurableEntries);
-  if (expandedLimit <= policy.maxDurableEntries || items.length <= policy.maxDurableEntries) {
-    return boundedItems;
-  }
-  const expansionCandidates = items.slice(0, expandedLimit);
-  const canExpand = expansionCandidates.length > policy.maxDurableEntries && expansionCandidates.every((item) => item.score >= policy.highConfidenceRecallThreshold);
-  if (canExpand) {
-    diagnostics.notices.push(`Before-turn durable recall expanded to ${expansionCandidates.length} high-confidence items.`);
-    return expansionCandidates;
-  }
-  diagnostics.notices.push(
-    `Before-turn durable recall kept the top ${boundedItems.length} item${boundedItems.length === 1 ? "" : "s"} because additional candidates were not high confidence.`
-  );
-  return boundedItems;
-}
 function inspectTurnSignal(currentTurnText) {
   const normalizedTurn = normalizeWhitespace(currentTurnText);
   const lowerTurn = normalizedTurn.toLowerCase();
@@ -730,18 +1046,6 @@ function normalizeRecentTurns(recentTurns, maxRecentTurns, currentTurnText) {
   }
   return deduped.slice(-maxRecentTurns);
 }
-function formatProjectedProvenance(provenance) {
-  const parts = [
-    provenance.supersededById ? `superseded_by=${provenance.supersededById}` : void 0,
-    provenance.supersessionKind ? `kind=${provenance.supersessionKind}` : void 0,
-    provenance.supersessionReason ? `reason=${provenance.supersessionReason}` : void 0,
-    provenance.supportSourceKind ? `support=${provenance.supportSourceKind}` : void 0,
-    provenance.supportMode ? `support_mode=${provenance.supportMode}` : void 0,
-    provenance.supportObservedAt ? `observed=${provenance.supportObservedAt}` : void 0,
-    provenance.supportLocator ? `locator=${provenance.supportLocator}` : void 0
-  ].filter((value) => value !== void 0);
-  return parts.length > 0 ? parts.join(" | ") : void 0;
-}
 function normalizeOptionalString(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
@@ -863,12 +1167,513 @@ function formatProcedureBodyLines(suggestion) {
   return lines;
 }
 
+// src/app/session-memory/predecessor-artifacts.ts
+var SESSION_START_ARTIFACT_KINDS = [
+  "compaction_checkpoint",
+  "branch_abandonment",
+  "session_episode"
+];
+async function resolvePredecessorSessionArtifacts(input, repository) {
+  const sessionKey = input.sessionKey.trim();
+  if (!sessionKey) {
+    return {
+      artifacts: []
+    };
+  }
+  const lineageEdge = await repository.getLatestLineageEdgeForChild(sessionKey);
+  const predecessorSessionKey = lineageEdge?.parentSessionKey?.trim();
+  const parentSourceRef = lineageEdge?.parentSourceRef?.trim();
+  if (!predecessorSessionKey && !parentSourceRef) {
+    return {
+      ...lineageEdge ? { lineageEdge } : {},
+      artifacts: []
+    };
+  }
+  const artifacts = predecessorSessionKey ? await repository.listSessionArtifacts({
+    sessionKey: predecessorSessionKey,
+    kinds: [...SESSION_START_ARTIFACT_KINDS],
+    limit: 10
+  }) : await repository.listSessionArtifactsBySourceRef({
+    sourceRef: parentSourceRef,
+    kinds: [...SESSION_START_ARTIFACT_KINDS],
+    limit: 10
+  });
+  return {
+    ...lineageEdge ? { lineageEdge } : {},
+    artifacts
+  };
+}
+
+// src/app/session-start/artifact-recall-query.ts
+var ARTIFACT_QUERY_TITLES = {
+  compaction_checkpoint: "Compaction checkpoint",
+  branch_abandonment: "Branch abandonment",
+  session_episode: "Session episode"
+};
+var SESSION_START_QUERY_ARTIFACT_ORDER = new Map(SESSION_START_ARTIFACT_KINDS.map((kind, index) => [kind, index]));
+function buildSessionStartArtifactRecallQuery(artifacts, maxChars) {
+  if (artifacts.length === 0 || maxChars <= 0) {
+    return void 0;
+  }
+  const orderedArtifacts = [...artifacts].sort(compareSessionStartArtifacts);
+  let remaining = maxChars;
+  const parts = [];
+  for (const artifact of orderedArtifacts) {
+    if (remaining <= 0) {
+      break;
+    }
+    const title = ARTIFACT_QUERY_TITLES[artifact.kind];
+    if (!title) {
+      continue;
+    }
+    const normalizedContent = normalizeWhitespace2(artifact.summary);
+    if (normalizedContent.length === 0) {
+      continue;
+    }
+    const labeled = `${title}: ${normalizedContent}`;
+    const truncated = truncate3(labeled, remaining);
+    if (truncated.length === 0) {
+      continue;
+    }
+    parts.push(truncated);
+    remaining -= truncated.length;
+  }
+  const query = normalizeWhitespace2(parts.join("\n"));
+  return query.length > 0 ? query : void 0;
+}
+function compareSessionStartArtifacts(left, right) {
+  const leftOrder = SESSION_START_QUERY_ARTIFACT_ORDER.get(left.kind) ?? Number.MAX_SAFE_INTEGER;
+  const rightOrder = SESSION_START_QUERY_ARTIFACT_ORDER.get(right.kind) ?? Number.MAX_SAFE_INTEGER;
+  if (leftOrder !== rightOrder) {
+    return leftOrder - rightOrder;
+  }
+  return right.createdAt.localeCompare(left.createdAt);
+}
+function normalizeWhitespace2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncate3(value, maxChars) {
+  if (maxChars <= 0) {
+    return "";
+  }
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+
+// src/app/session-start/service.ts
+var DEFAULT_MAX_CORE_ENTRIES = 4;
+var DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES = 3;
+var DEFAULT_MAX_DURABLE_ENTRIES2 = 5;
+var DEFAULT_MAX_ARTIFACT_CHARS = 1200;
+var DEFAULT_MAX_PROFILE_SNAPSHOT_AGE_HOURS = 48;
+async function runSessionStart(input, deps) {
+  const policy = normalizePolicy2(input.policy);
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const profileSnapshot = await deps.repository.getActiveProfileSnapshot(policy.maxProfileSnapshotAgeHours * 60 * 60 * 1e3, now);
+  const profileEntries = profileSnapshot ? filterCurrentEntries2(await deps.repository.listEntriesByIds(profileSnapshot.durableIds), nowMs) : [];
+  const profileItems = profileEntries.map((entry) => buildProfilePatchItem(entry, profileSnapshot?.id ?? "unknown", nowMs));
+  const proactiveDirectiveEntries = filterCurrentEntries2(await deps.listActiveProactiveDirectives?.() ?? [], nowMs);
+  const proactiveDirectiveItems = proactiveDirectiveEntries.map((entry) => buildDirectivePatchItem(entry, nowMs));
+  const coreEntries = await deps.repository.listCoreEntries(policy.maxCoreEntries, now);
+  const coreItems = coreEntries.map((entry) => buildCorePatchItem(entry, nowMs));
+  const diagnostics = {
+    coreCandidateCount: coreEntries.length,
+    profileCandidateCount: profileEntries.length,
+    ...profileSnapshot ? { activeProfileSnapshotId: profileSnapshot.id } : {},
+    proactiveDirectiveCandidateCount: proactiveDirectiveEntries.length,
+    artifactRecallCandidateCount: 0,
+    artifactRecallUsed: false,
+    notices: []
+  };
+  const artifactRecallQuery = await resolveSessionStartArtifactRecallQuery(input.sessionKey, policy, deps);
+  if (!policy.enableArtifactRecall) {
+    diagnostics.notices.push("Artifact-grounded durable recall disabled by session-start policy.");
+  }
+  const artifactRecallItems = artifactRecallQuery ? await runArtifactRecallSelection(artifactRecallQuery, input.sessionKey, policy, deps, diagnostics) : [];
+  const mergedDurableMemory = mergeDurableMemory(profileItems, proactiveDirectiveItems, coreItems, artifactRecallItems, policy.maxDurableEntries);
+  const visibleDurableMemory = await applyAbstainDirectivesForInjection(mergedDurableMemory, deps.listActiveAbstainDirectives, diagnostics);
+  const durableMemory = assignRanks2(visibleDurableMemory);
+  return {
+    durableMemory,
+    diagnostics
+  };
+}
+async function resolveSessionStartArtifactRecallQuery(sessionKey, policy, deps) {
+  if (!policy.enableArtifactRecall) {
+    return void 0;
+  }
+  const normalizedSessionKey = sessionKey?.trim();
+  if (!normalizedSessionKey || !deps.sessionMemoryRepository) {
+    return void 0;
+  }
+  const predecessor = await resolvePredecessorSessionArtifacts({ sessionKey: normalizedSessionKey }, deps.sessionMemoryRepository);
+  return buildSessionStartArtifactRecallQuery(predecessor.artifacts, policy.maxArtifactChars);
+}
+function buildProfilePatchItem(entry, snapshotId, nowMs) {
+  return {
+    rank: 0,
+    entry,
+    sourceKind: "profile",
+    whySurfaced: {
+      summary: `active profile snapshot ${snapshotId}`,
+      reasons: ["active profile snapshot", `snapshot ${snapshotId}`, `importance ${entry.importance}`]
+    },
+    memoryState: resolveMemoryState(entry, nowMs),
+    claimStatus: resolveClaimStatus(entry),
+    freshnessLabel: buildFreshnessLabel(entry),
+    ...buildProvenanceSummary(entry) ? { provenanceSummary: buildProvenanceSummary(entry) } : {}
+  };
+}
+function buildDirectivePatchItem(entry, nowMs) {
+  const metadata = parseDirectiveMetadata(entry);
+  return {
+    rank: 0,
+    entry,
+    sourceKind: "directive",
+    whySurfaced: {
+      summary: `proactive memory directive; trigger ${metadata?.trigger ?? "session_start"}`,
+      reasons: ["proactive memory directive", `trigger ${metadata?.trigger ?? "session_start"}`, `importance ${entry.importance}`]
+    },
+    memoryState: resolveMemoryState(entry, nowMs),
+    claimStatus: resolveClaimStatus(entry),
+    freshnessLabel: buildFreshnessLabel(entry),
+    ...buildProvenanceSummary(entry) ? { provenanceSummary: buildProvenanceSummary(entry) } : {}
+  };
+}
+async function runArtifactRecallSelection(query, sessionKey, policy, deps, diagnostics) {
+  diagnostics.artifactRecallUsed = true;
+  diagnostics.artifactRecallQuery = query;
+  let artifactRecallTrace;
+  try {
+    const recalled = await recall(
+      {
+        text: query,
+        limit: policy.maxArtifactRecallEntries,
+        threshold: policy.recallThreshold,
+        sessionKey
+      },
+      deps.recall,
+      {
+        trace: {
+          reportSummary(summary) {
+            artifactRecallTrace = summary;
+          }
+        },
+        slotPolicyConfig: deps.slotPolicyConfig,
+        ...deps.now ? { now: deps.now } : {}
+      }
+    );
+    diagnostics.artifactRecallTrace = artifactRecallTrace;
+    diagnostics.artifactRecallCandidateCount = recalled.length;
+    if (artifactRecallTrace?.degraded.notices.length) {
+      diagnostics.notices.push(...artifactRecallTrace.degraded.notices);
+    }
+    return recalled.map((item) => buildArtifactRecallPatchItem(item, deps));
+  } catch (error) {
+    diagnostics.artifactRecallTrace = artifactRecallTrace;
+    diagnostics.notices.push(`Artifact-grounded durable recall failed: ${formatErrorMessage2(error)}`);
+    return [];
+  }
+}
+function buildCorePatchItem(entry, nowMs) {
+  return {
+    rank: 0,
+    entry,
+    sourceKind: "core",
+    whySurfaced: {
+      summary: `always-on core memory; importance ${entry.importance}`,
+      reasons: ["always-on core memory", `importance ${entry.importance}`, `expiry ${entry.expiry}`]
+    },
+    memoryState: resolveMemoryState(entry, nowMs),
+    claimStatus: resolveClaimStatus(entry),
+    freshnessLabel: buildFreshnessLabel(entry),
+    ...buildProvenanceSummary(entry) ? { provenanceSummary: buildProvenanceSummary(entry) } : {}
+  };
+}
+function buildArtifactRecallPatchItem(recalled, deps) {
+  const projected = projectClaimCentricRecallEntry(recalled, {
+    slotPolicyConfig: deps.slotPolicyConfig
+  });
+  return {
+    rank: 0,
+    entry: recalled.entry,
+    sourceKind: "artifact_recall",
+    score: recalled.score,
+    whySurfaced: projected.whySurfaced,
+    memoryState: projected.memoryState,
+    claimStatus: projected.claimStatus,
+    freshnessLabel: projected.freshness.label,
+    ...formatProjectedProvenance2(projected.provenance) ? { provenanceSummary: formatProjectedProvenance2(projected.provenance) } : {}
+  };
+}
+function mergeDurableMemory(profileItems, directiveItems, coreItems, artifactRecallItems, maxDurableEntries) {
+  const merged = [];
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  const tryAdd = (item) => {
+    if (merged.length >= maxDurableEntries || seenEntryIds.has(item.entry.id)) {
+      return false;
+    }
+    seenEntryIds.add(item.entry.id);
+    merged.push(item);
+    return true;
+  };
+  const addFrom = (items, maxAdd = Number.POSITIVE_INFINITY) => {
+    let added = 0;
+    for (const item of items) {
+      if (merged.length >= maxDurableEntries || added >= maxAdd) {
+        return;
+      }
+      if (tryAdd(item)) {
+        added += 1;
+      }
+    }
+  };
+  addFrom(profileItems);
+  addFrom(directiveItems);
+  if (merged.length >= maxDurableEntries) {
+    return merged;
+  }
+  const uniqueArtifact = artifactRecallItems.find((item) => !seenEntryIds.has(item.entry.id));
+  const remainingSlots = maxDurableEntries - merged.length;
+  const coreLimit = uniqueArtifact ? Math.max(0, remainingSlots - 1) : remainingSlots;
+  addFrom(coreItems, coreLimit);
+  if (uniqueArtifact) {
+    tryAdd(uniqueArtifact);
+  }
+  addFrom(coreItems);
+  addFrom(artifactRecallItems);
+  return merged;
+}
+function assignRanks2(items) {
+  return items.map((item, index) => ({
+    ...item,
+    rank: index + 1
+  }));
+}
+function normalizePolicy2(policy) {
+  const maxCoreEntries = normalizeCount2(policy?.maxCoreEntries, DEFAULT_MAX_CORE_ENTRIES);
+  const maxArtifactRecallEntries = normalizeCount2(policy?.maxArtifactRecallEntries, DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES);
+  const maxDurableEntries = Math.max(maxCoreEntries, normalizeCount2(policy?.maxDurableEntries, DEFAULT_MAX_DURABLE_ENTRIES2));
+  return {
+    maxCoreEntries,
+    enableArtifactRecall: policy?.enableArtifactRecall !== false,
+    maxArtifactRecallEntries,
+    maxDurableEntries,
+    maxArtifactChars: normalizeCount2(policy?.maxArtifactChars, DEFAULT_MAX_ARTIFACT_CHARS),
+    recallThreshold: normalizeThreshold2(policy?.recallThreshold),
+    maxProfileSnapshotAgeHours: normalizeCount2(policy?.maxProfileSnapshotAgeHours, DEFAULT_MAX_PROFILE_SNAPSHOT_AGE_HOURS)
+  };
+}
+function filterCurrentEntries2(entries, nowMs) {
+  return entries.filter((entry) => isWithinValidityWindow(entry.valid_from, entry.valid_to, nowMs));
+}
+function normalizeCount2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeThreshold2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function resolveMemoryState(entry, nowMs) {
+  if (entry.superseded_by) {
+    return "superseded";
+  }
+  if (!isCurrentlyValidMemory(entry, nowMs)) {
+    return "historical";
+  }
+  return "current";
+}
+function resolveClaimStatus(entry) {
+  return resolveKeyedDurableLifecycleStatus(entry);
+}
+function buildFreshnessLabel(entry) {
+  const parts = [`created ${entry.created_at}`];
+  const validFrom = normalizeOptionalString2(entry.valid_from);
+  const validTo = normalizeOptionalString2(entry.valid_to);
+  if (validFrom || validTo) {
+    parts.push(`valid ${validFrom ?? "?"} -> ${validTo ?? "ongoing"}`);
+  }
+  return parts.join(" | ");
+}
+function buildProvenanceSummary(entry) {
+  const parts = [
+    entry.superseded_by ? `superseded_by=${entry.superseded_by}` : void 0,
+    entry.supersession_kind ? `kind=${entry.supersession_kind}` : void 0,
+    entry.supersession_reason ? `reason=${entry.supersession_reason}` : void 0,
+    entry.claim_support_source_kind ? `support=${entry.claim_support_source_kind}` : void 0,
+    entry.claim_support_mode ? `support_mode=${entry.claim_support_mode}` : void 0,
+    entry.claim_support_observed_at ? `observed=${entry.claim_support_observed_at}` : void 0,
+    entry.claim_support_locator ? `locator=${entry.claim_support_locator}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function formatProjectedProvenance2(provenance) {
+  const parts = [
+    provenance.supersededById ? `superseded_by=${provenance.supersededById}` : void 0,
+    provenance.supersessionKind ? `kind=${provenance.supersessionKind}` : void 0,
+    provenance.supersessionReason ? `reason=${provenance.supersessionReason}` : void 0,
+    provenance.supportSourceKind ? `support=${provenance.supportSourceKind}` : void 0,
+    provenance.supportMode ? `support_mode=${provenance.supportMode}` : void 0,
+    provenance.supportObservedAt ? `observed=${provenance.supportObservedAt}` : void 0,
+    provenance.supportLocator ? `locator=${provenance.supportLocator}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function normalizeOptionalString2(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function formatErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/adapters/db/directives-repository.ts
+var MAX_DIRECTIVES = 50;
+async function listActiveAbstainDirectives(executor, now = /* @__PURE__ */ new Date()) {
+  const nowIso = now.toISOString();
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE ${buildActiveDurableClause()}
+        AND (
+          (type = 'directive' AND directive_polarity = 'abstain')
+          OR (claim_key LIKE ? AND (directive_polarity IS NULL OR directive_polarity = 'abstain'))
+        )
+        AND ${buildValidAsOfClause()}
+      ORDER BY created_at DESC
+      LIMIT ?
+    `,
+    args: [`${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX}%`, nowIso, nowIso, MAX_DIRECTIVES]
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+async function listActiveSessionStartProactiveDirectives(executor, now = /* @__PURE__ */ new Date()) {
+  const nowIso = now.toISOString();
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE ${buildActiveDurableClause()}
+        AND type = 'directive'
+        AND directive_polarity = 'proactive'
+        AND directive_trigger IN ('session_start', 'always')
+        AND ${buildValidAsOfClause()}
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [nowIso, nowIso, MAX_DIRECTIVES]
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+async function listActiveTopicProactiveDirectives(executor, now = /* @__PURE__ */ new Date()) {
+  const nowIso = now.toISOString();
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE ${buildActiveDurableClause()}
+        AND type = 'directive'
+        AND directive_polarity = 'proactive'
+        AND directive_trigger LIKE 'topic:%'
+        AND ${buildValidAsOfClause()}
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [nowIso, nowIso, MAX_DIRECTIVES]
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+
+// src/adapters/db/session-start-repository.ts
+function createSessionStartRepository(executor) {
+  return {
+    listCoreEntries: async (limit, now) => listCoreEntries(executor, limit, now),
+    getActiveProfileSnapshot: async (maxAgeMs, now) => getActiveProfileSnapshot(executor, maxAgeMs, now),
+    listEntriesByIds: async (ids) => getDurables(executor, ids)
+  };
+}
+async function getActiveProfileSnapshot(executor, maxAgeMs, now = /* @__PURE__ */ new Date()) {
+  if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) {
+    return null;
+  }
+  const minCreatedAt = new Date(now.getTime() - maxAgeMs).toISOString();
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        p.id,
+        p.durable_ids,
+        p.directive_ids,
+        p.as_of,
+        p.run_id,
+        p.created_at
+      FROM dream_state AS s
+      JOIN profile_snapshots AS p ON p.id = s.active_profile_snapshot_id
+      WHERE s.id = 'default'
+        AND datetime(p.created_at) >= datetime(?)
+      LIMIT 1
+    `,
+    args: [minCreatedAt]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    id: readRequiredString(row, "id"),
+    durableIds: parseJsonStringArray(readOptionalString(row, "durable_ids")),
+    directiveIds: parseJsonStringArray(readOptionalString(row, "directive_ids")),
+    asOf: readRequiredString(row, "as_of"),
+    runId: readOptionalString(row, "run_id") ?? null,
+    createdAt: readRequiredString(row, "created_at")
+  };
+}
+async function listCoreEntries(executor, limit, now = /* @__PURE__ */ new Date()) {
+  if (limit <= 0) {
+    return [];
+  }
+  const nowIso = now.toISOString();
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE ${buildActiveDurableClause()}
+        AND expiry = 'core'
+        AND ${buildValidAsOfClause()}
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [nowIso, nowIso, limit]
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+
 export {
   runBeforeTurn,
+  listActiveAbstainDirectives,
+  listActiveSessionStartProactiveDirectives,
+  listActiveTopicProactiveDirectives,
+  createSessionStartRepository,
   formatInjectionEntryHeader,
   formatInjectionEntryBodyLines,
   wrapAgenrMemoryContext,
   containsAgenrMemoryContext,
   stripAgenrMemoryContext,
-  formatAgenrBeforeTurnRecall
+  formatAgenrBeforeTurnRecall,
+  runSessionStart
 };