agenr 3.1.0 → 3.3.0

package/dist/adapters/skeln/index.js

@@ -1,70 +1,353 @@
 import {
-  CLOSE_EVENT_HISTORY_LIMIT,
-  EPISODE_SUMMARY_TIMEOUT_MS,
-  FETCH_TOOL_PARAMETERS,
-  RECALL_TOOL_PARAMETERS,
-  SESSION_LINEAGE_REASONS,
-  STORE_TOOL_PARAMETERS,
-  UPDATE_TOOL_PARAMETERS,
-  WORKING_CANDIDATE_PROMOTION_STATUSES,
-  buildRecallToolServices,
-  composeHostPluginServices,
-  createClaimExtractionFromAgenrConfig,
-  createDeadlineAwareEpisodeSummaryLlm,
-  createSessionStartTracker,
-  embedEpisodeSummaryWithinBudget,
-  extractRecentTurnsFromMessages,
-  formatAgenrSessionStartRecall,
-  formatUnifiedRecallResults,
-  isCloseManagedStatus,
-  isModelVisibleOperationType,
-  isMutableWorkingSetStatus,
-  isTrustedHostMutationSource,
-  isTrustedHostOnlyWorkingOperation,
-  normalizeEventLimit,
-  normalizeListLimit,
-  normalizeOptionalString,
-  normalizePluginInjectionMemoryPolicyConfig,
-  normalizePromptText,
-  parseFetchToolParams,
-  parseRecallToolParams,
-  parseStoreToolParams,
-  parseUpdateToolParams,
-  resolveBeforeTurnPolicy,
-  resolveSessionIdentityKey,
-  resolveSessionStartPolicy,
-  resolveWorkingContextGate,
-  runFetchMemoryTool,
-  runRecallMemoryTool,
-  runSessionStart,
-  runStoreMemoryTool,
-  runUpdateMemoryTool,
-  writeBoundedSingleTranscriptEpisode
-} from "../../chunk-E2DHUFZK.js";
-import {
+  ENTRY_TYPE_DESCRIPTION,
+  EXPIRY_DESCRIPTION,
+  RECALL_MODES,
+  UPDATE_EXPIRY_DESCRIPTION,
   asRecord,
+  buildEntryMemoryResolverPorts,
+  createMemoryRepository,
   createSingleTranscriptDiscoveryPort,
   formatErrorMessage,
   formatTargetSelector,
+  ingestEpisodeTranscript,
+  normalizeStringArray,
+  parseEntryType,
+  parseEntryTypes,
+  parseExpiry,
+  parseRecallMode,
+  resolveTargetEntry,
   sanitizeFetchToolParams,
-  sanitizeUpdateToolParams
-} from "../../chunk-EEEL53X4.js";
+  sanitizeUpdateToolParams,
+  storeEntriesDetailed
+} from "../../chunk-M5M65AYP.js";
 import {
+  containsAgenrMemoryContext,
   formatAgenrBeforeTurnRecall,
-  runBeforeTurn
-} from "../../chunk-V5CDMHRN.js";
+  formatInjectionEntryBodyLines,
+  formatInjectionEntryHeader,
+  runBeforeTurn,
+  stripAgenrMemoryContext,
+  wrapAgenrMemoryContext
+} from "../../chunk-KH52KJSJ.js";
 import {
   AGENR_FEATURE_FLAG_KEYS,
   DEFAULT_AGENR_FEATURE_FLAGS,
+  ENTRY_PREVIEW_MAX_CHARS,
+  ENTRY_SELECT_COLUMNS,
+  ENTRY_TYPES,
+  assertEntryFetchableContentLength,
+  attachCrossEncoderPort,
+  buildActiveEntryClause,
+  buildEntryRecallPreview,
+  buildFetchToolDetails,
   buildRecallToolDetails,
+  createDatabase,
+  createEmbeddingClient,
   createLlmClient,
+  createOpenAICrossEncoder,
+  createRecallAdapter,
+  formatFetchedEntryText,
   isRecord,
+  mapEntryRow,
+  normalizeManualClaimKeyUpdate,
+  projectClaimCentricRecallEntry,
+  readConfig,
+  readNumber,
   readOptionalFiniteNumber,
+  readOptionalString,
   readOptionalTrimmedString,
+  readRequiredString,
+  recallResultHasTruncatedEntryPreviews,
+  resolveClaimExtractionConfig,
+  resolveConfigPath,
+  resolveCrossEncoderApiKey,
+  resolveDbPath,
+  resolveEmbeddingApiKey,
+  resolveEmbeddingModel,
   resolveLlmApiKey,
-  resolveModel
-} from "../../chunk-NNO2V4GH.js";
-import "../../chunk-5LADPJ4C.js";
+  resolveModel,
+  runUnifiedRecall,
+  truncate,
+  validateTemporalValidityRange
+} from "../../chunk-Z5X7T4QZ.js";
+import {
+  recall
+} from "../../chunk-5LADPJ4C.js";
+
+// src/app/plugin-runtime/session-tracking.ts
+function resolveSessionIdentityKey(sessionId, sessionKey) {
+  const normalizedSessionId = sessionId?.trim();
+  if (normalizedSessionId) {
+    return `session:${normalizedSessionId}`;
+  }
+  const normalizedSessionKey = sessionKey?.trim();
+  if (normalizedSessionKey) {
+    return `key:${normalizedSessionKey}`;
+  }
+  return void 0;
+}
+function createSessionStartTracker() {
+  const seenSessionIdentities = /* @__PURE__ */ new Set();
+  const resumedFromBySessionId = /* @__PURE__ */ new Map();
+  return {
+    consume(sessionId, sessionKey) {
+      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
+      if (!identityKey) {
+        return {
+          isFirst: false,
+          activeCount: seenSessionIdentities.size
+        };
+      }
+      if (seenSessionIdentities.has(identityKey)) {
+        return {
+          isFirst: false,
+          activeCount: seenSessionIdentities.size
+        };
+      }
+      seenSessionIdentities.add(identityKey);
+      return {
+        isFirst: true,
+        activeCount: seenSessionIdentities.size
+      };
+    },
+    rememberSessionStart(sessionId, _sessionKey, resumedFrom) {
+      const normalizedSessionId = sessionId?.trim();
+      const normalizedResumedFrom = resumedFrom?.trim();
+      if (!normalizedSessionId || !normalizedResumedFrom) {
+        return;
+      }
+      resumedFromBySessionId.set(normalizedSessionId, normalizedResumedFrom);
+    },
+    getResumedFrom(sessionId) {
+      const normalizedSessionId = sessionId?.trim();
+      return normalizedSessionId ? resumedFromBySessionId.get(normalizedSessionId) : void 0;
+    }
+  };
+}
+
+// src/adapters/shared/plugin-config-validators.ts
+function normalizeOptionalBoolean(value, label, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    errors.push(`${label} must be a boolean when provided`);
+    return void 0;
+  }
+  return value;
+}
+function normalizeOptionalPositiveInteger(value, label, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+    errors.push(`${label} must be a positive integer when provided`);
+    return void 0;
+  }
+  return value;
+}
+function normalizeOptionalUnitInterval(value, label, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    errors.push(`${label} must be a number between 0 and 1 when provided`);
+    return void 0;
+  }
+  return value;
+}
+
+// src/adapters/shared/plugin-memory-policy-config.ts
+function normalizePluginInjectionMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord2(value)) {
+    return { ok: false, errors: ["memoryPolicy must be an object when provided"] };
+  }
+  const errors = [];
+  const slotPoliciesResult = normalizeClaimSlotPolicyConfig(value.slotPolicies);
+  if (!slotPoliciesResult.ok) {
+    errors.push(...slotPoliciesResult.errors);
+  }
+  const sessionStartResult = normalizeSessionStartMemoryPolicyConfig(value.sessionStart);
+  if (!sessionStartResult.ok) {
+    errors.push(...sessionStartResult.errors);
+  }
+  const beforeTurnResult = normalizeBeforeTurnMemoryPolicyConfig(value.beforeTurn);
+  if (!beforeTurnResult.ok) {
+    errors.push(...beforeTurnResult.errors);
+  }
+  const workingContextResult = normalizeWorkingContextMemoryPolicyConfig(value.workingContext);
+  if (!workingContextResult.ok) {
+    errors.push(...workingContextResult.errors);
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies", "sessionStart", "beforeTurn", "workingContext"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: slotPoliciesResult.ok && slotPoliciesResult.value || sessionStartResult.ok && sessionStartResult.value || beforeTurnResult.ok && beforeTurnResult.value || workingContextResult.ok && workingContextResult.value ? {
+      ...slotPoliciesResult.ok && slotPoliciesResult.value ? { slotPolicies: slotPoliciesResult.value } : {},
+      ...sessionStartResult.ok && sessionStartResult.value ? { sessionStart: sessionStartResult.value } : {},
+      ...beforeTurnResult.ok && beforeTurnResult.value ? { beforeTurn: beforeTurnResult.value } : {},
+      ...workingContextResult.ok && workingContextResult.value ? { workingContext: workingContextResult.value } : {}
+    } : void 0
+  };
+}
+function normalizeWorkingContextMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord2(value)) {
+    return { ok: false, errors: ["memoryPolicy.workingContext must be an object when provided"] };
+  }
+  const errors = [];
+  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.workingContext.enabled", errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["enabled"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.workingContext.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: enabled !== void 0 ? { enabled } : void 0
+  };
+}
+function normalizeSessionStartMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord2(value)) {
+    return { ok: false, errors: ["memoryPolicy.sessionStart must be an object when provided"] };
+  }
+  const errors = [];
+  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.sessionStart.enabled", errors);
+  const coreMemory = normalizeOptionalBoolean(value.coreMemory, "memoryPolicy.sessionStart.coreMemory", errors);
+  const relevantDurableMemory = normalizeOptionalBoolean(value.relevantDurableMemory, "memoryPolicy.sessionStart.relevantDurableMemory", errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["enabled", "coreMemory", "relevantDurableMemory"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.sessionStart.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: enabled !== void 0 || coreMemory !== void 0 || relevantDurableMemory !== void 0 ? {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...coreMemory !== void 0 ? { coreMemory } : {},
+      ...relevantDurableMemory !== void 0 ? { relevantDurableMemory } : {}
+    } : void 0
+  };
+}
+function normalizeBeforeTurnMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord2(value)) {
+    return { ok: false, errors: ["memoryPolicy.beforeTurn must be an object when provided"] };
+  }
+  const errors = [];
+  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.beforeTurn.enabled", errors);
+  const procedureSuggestion = normalizeOptionalBoolean(value.procedureSuggestion, "memoryPolicy.beforeTurn.procedureSuggestion", errors);
+  const maxDurableEntries = normalizeOptionalPositiveInteger(value.maxDurableEntries, "memoryPolicy.beforeTurn.maxDurableEntries", errors);
+  const recallThreshold = normalizeOptionalUnitInterval(value.recallThreshold, "memoryPolicy.beforeTurn.recallThreshold", errors);
+  const highConfidenceRecallThreshold = normalizeOptionalUnitInterval(
+    value.highConfidenceRecallThreshold,
+    "memoryPolicy.beforeTurn.highConfidenceRecallThreshold",
+    errors
+  );
+  const procedureThreshold = normalizeOptionalUnitInterval(value.procedureThreshold, "memoryPolicy.beforeTurn.procedureThreshold", errors);
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "enabled",
+    "procedureSuggestion",
+    "maxDurableEntries",
+    "recallThreshold",
+    "highConfidenceRecallThreshold",
+    "procedureThreshold"
+  ]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.beforeTurn.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: enabled !== void 0 || procedureSuggestion !== void 0 || maxDurableEntries !== void 0 || recallThreshold !== void 0 || highConfidenceRecallThreshold !== void 0 || procedureThreshold !== void 0 ? {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...procedureSuggestion !== void 0 ? { procedureSuggestion } : {},
+      ...maxDurableEntries !== void 0 ? { maxDurableEntries } : {},
+      ...recallThreshold !== void 0 ? { recallThreshold } : {},
+      ...highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold } : {},
+      ...procedureThreshold !== void 0 ? { procedureThreshold } : {}
+    } : void 0
+  };
+}
+function normalizeClaimSlotPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord2(value)) {
+    return { ok: false, errors: ["memoryPolicy.slotPolicies must be an object when provided"] };
+  }
+  const errors = [];
+  const attributeHeads = normalizeClaimSlotPolicyAttributeHeads(value.attributeHeads, errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["attributeHeads"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.slotPolicies.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: attributeHeads ? { attributeHeads } : void 0
+  };
+}
+function normalizeClaimSlotPolicyAttributeHeads(value, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(value)) {
+    errors.push("memoryPolicy.slotPolicies.attributeHeads must be an object when provided");
+    return void 0;
+  }
+  const normalized = {};
+  for (const [rawKey, rawPolicy] of Object.entries(value)) {
+    const attributeHead = rawKey.trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9_-]*$/.test(attributeHead)) {
+      errors.push(`memoryPolicy.slotPolicies.attributeHeads.${rawKey} must use a canonical attribute-head label`);
+      continue;
+    }
+    if (rawPolicy !== "exclusive" && rawPolicy !== "multivalued") {
+      errors.push(`memoryPolicy.slotPolicies.attributeHeads.${attributeHead} must be "exclusive" or "multivalued"`);
+      continue;
+    }
+    normalized[attributeHead] = rawPolicy;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/adapters/skeln/config.ts
 function parseSkelnMemoryPolicyJson(raw) {
@@ -305,6 +588,312 @@ function toWorkingContextAuditPointer(projection) {
   };
 }
 
+// src/app/session-memory/normalize.ts
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+
+// src/app/session-start/context-sections.ts
+function buildSessionStartContextSections(continuitySummaryText, recentSessionText) {
+  const sections = [];
+  const normalizedContinuitySummary = normalizeOptionalString(continuitySummaryText);
+  if (normalizedContinuitySummary) {
+    sections.push({
+      kind: "continuity_summary",
+      title: "Previous session summary",
+      content: normalizedContinuitySummary
+    });
+  }
+  const normalizedRecentSession = normalizeOptionalString(recentSessionText);
+  if (normalizedRecentSession) {
+    sections.push({
+      kind: "recent_session",
+      title: "Recent session",
+      content: normalizedRecentSession
+    });
+  }
+  return sections;
+}
+
+// src/app/session-start/service.ts
+var DEFAULT_MAX_CORE_ENTRIES = 4;
+var DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES = 3;
+var DEFAULT_MAX_DURABLE_ENTRIES = 5;
+var DEFAULT_MAX_ARTIFACT_CHARS = 1200;
+async function runSessionStart(input, deps) {
+  const policy = normalizePolicy(input.policy);
+  const contextSections = buildSessionStartContextSections(input.continuitySummaryText, input.recentSessionText);
+  const coreEntries = await deps.repository.listCoreEntries(policy.maxCoreEntries);
+  const coreItems = coreEntries.map((entry) => buildCorePatchItem(entry));
+  const diagnostics = {
+    coreCandidateCount: coreEntries.length,
+    artifactRecallCandidateCount: 0,
+    artifactRecallUsed: false,
+    notices: []
+  };
+  const artifactRecallQuery = policy.enableArtifactRecall ? buildArtifactRecallQuery(contextSections, policy.maxArtifactChars) : void 0;
+  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 durableMemory = assignRanks(mergeDurableMemory(coreItems, artifactRecallItems, policy.maxDurableEntries));
+  return {
+    contextSections,
+    durableMemory,
+    diagnostics
+  };
+}
+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
+      }
+    );
+    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) {
+  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),
+    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,
+    ...formatProjectedProvenance(projected.provenance) ? { provenanceSummary: formatProjectedProvenance(projected.provenance) } : {}
+  };
+}
+function buildArtifactRecallQuery(sections, maxChars) {
+  if (sections.length === 0 || maxChars <= 0) {
+    return void 0;
+  }
+  let remaining = maxChars;
+  const parts = [];
+  for (const section of sections) {
+    if (remaining <= 0) {
+      break;
+    }
+    const normalizedContent = normalizeWhitespace(section.content);
+    if (normalizedContent.length === 0) {
+      continue;
+    }
+    const labeled = `${section.title}: ${normalizedContent}`;
+    const truncated = truncate2(labeled, remaining);
+    if (truncated.length === 0) {
+      continue;
+    }
+    parts.push(truncated);
+    remaining -= truncated.length;
+  }
+  const query = normalizeWhitespace(parts.join("\n"));
+  return query.length > 0 ? query : void 0;
+}
+function mergeDurableMemory(coreItems, artifactRecallItems, maxDurableEntries) {
+  const merged = [];
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  for (const item of [...coreItems, ...artifactRecallItems]) {
+    if (seenEntryIds.has(item.entry.id)) {
+      continue;
+    }
+    seenEntryIds.add(item.entry.id);
+    merged.push(item);
+    if (merged.length >= maxDurableEntries) {
+      break;
+    }
+  }
+  return merged;
+}
+function assignRanks(items) {
+  return items.map((item, index) => ({
+    ...item,
+    rank: index + 1
+  }));
+}
+function normalizePolicy(policy) {
+  const maxCoreEntries = normalizeCount(policy?.maxCoreEntries, DEFAULT_MAX_CORE_ENTRIES);
+  const maxArtifactRecallEntries = normalizeCount(policy?.maxArtifactRecallEntries, DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES);
+  const maxDurableEntries = Math.max(maxCoreEntries, normalizeCount(policy?.maxDurableEntries, DEFAULT_MAX_DURABLE_ENTRIES));
+  return {
+    maxCoreEntries,
+    enableArtifactRecall: policy?.enableArtifactRecall !== false,
+    maxArtifactRecallEntries,
+    maxDurableEntries,
+    maxArtifactChars: normalizeCount(policy?.maxArtifactChars, DEFAULT_MAX_ARTIFACT_CHARS),
+    recallThreshold: normalizeThreshold(policy?.recallThreshold)
+  };
+}
+function normalizeCount(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeThreshold(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function resolveMemoryState(entry) {
+  if (entry.superseded_by) {
+    return "superseded";
+  }
+  if (entry.retired || entry.valid_to) {
+    return "historical";
+  }
+  return "current";
+}
+function resolveClaimStatus(entry) {
+  if (!normalizeOptionalString2(entry.claim_key)) {
+    return "no_key";
+  }
+  return entry.claim_key_status ?? "legacy";
+}
+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 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 normalizeOptionalString2(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncate2(value, maxChars) {
+  if (maxChars <= 0) {
+    return "";
+  }
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+function formatErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/adapters/shared/injection/session-start-format.ts
+function formatAgenrSessionStartRecall(patch) {
+  if (patch.contextSections.length === 0 && patch.durableMemory.length === 0) {
+    return "";
+  }
+  const lines = [];
+  for (const section of patch.contextSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
+    lines.push("");
+  }
+  const durableSections = buildSections(patch);
+  if (durableSections.length > 0) {
+    const recallLines = [
+      "## Agenr Session Recall",
+      "Use this as prior context. Confirm anything important if the current conversation conflicts with it.",
+      ""
+    ];
+    for (const section of durableSections) {
+      recallLines.push(`### ${section.title}`);
+      for (const item of section.entries) {
+        recallLines.push(formatInjectionEntryHeader(item));
+        recallLines.push(...formatInjectionEntryBodyLines(item));
+      }
+      recallLines.push("");
+    }
+    lines.push(wrapAgenrMemoryContext(recallLines.join("\n").trim()));
+  }
+  return lines.join("\n").trim();
+}
+function buildSections(patch) {
+  const sections = [];
+  const coreEntries = patch.durableMemory.filter((item) => item.sourceKind === "core");
+  if (coreEntries.length > 0) {
+    sections.push({ title: "Core Memory", entries: coreEntries });
+  }
+  const artifactRecallEntries = patch.durableMemory.filter((item) => item.sourceKind === "artifact_recall");
+  if (artifactRecallEntries.length > 0) {
+    sections.push({ title: "Relevant Durable Memory", entries: artifactRecallEntries });
+  }
+  return sections;
+}
+
 // src/adapters/skeln/session/scope.ts
 function resolveSkelnSessionKey(sessionId, cwd) {
   const normalizedSessionId = sessionId.trim();
@@ -522,6 +1111,171 @@ function traceSystemPromptDoctrineInjected(baseSystemPrompt, updatedSystemPrompt
   });
 }
 
+// src/adapters/shared/injection/policy.ts
+var DEFAULT_SESSION_START_POLICY = {
+  maxCoreEntries: 4,
+  maxArtifactRecallEntries: 3,
+  maxDurableEntries: 5,
+  maxArtifactChars: 1200
+};
+var DEFAULT_BEFORE_TURN_POLICY = {
+  maxDurableEntries: 1,
+  maxHighConfidenceDurableEntries: 2,
+  maxRecentTurns: 2,
+  maxQueryChars: 450,
+  maxProcedureCandidates: 3,
+  recallThreshold: 0.6,
+  highConfidenceRecallThreshold: 0.85,
+  procedureThreshold: 0.72
+};
+function resolveSessionStartPolicy(memoryPolicy) {
+  return {
+    ...DEFAULT_SESSION_START_POLICY,
+    ...memoryPolicy?.sessionStart?.coreMemory === false ? { maxCoreEntries: 0 } : {},
+    enableArtifactRecall: memoryPolicy?.sessionStart?.relevantDurableMemory !== false
+  };
+}
+function resolveBeforeTurnPolicy(memoryPolicy) {
+  return {
+    ...DEFAULT_BEFORE_TURN_POLICY,
+    enableProcedureSuggestion: memoryPolicy?.beforeTurn?.procedureSuggestion !== false,
+    ...memoryPolicy?.beforeTurn?.maxDurableEntries !== void 0 ? { maxDurableEntries: memoryPolicy.beforeTurn.maxDurableEntries } : {},
+    ...memoryPolicy?.beforeTurn?.recallThreshold !== void 0 ? { recallThreshold: memoryPolicy.beforeTurn.recallThreshold } : {},
+    ...memoryPolicy?.beforeTurn?.highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold: memoryPolicy.beforeTurn.highConfidenceRecallThreshold } : {},
+    ...memoryPolicy?.beforeTurn?.procedureThreshold !== void 0 ? { procedureThreshold: memoryPolicy.beforeTurn.procedureThreshold } : {}
+  };
+}
+function isWorkingContextPolicyEnabled(memoryPolicy) {
+  return memoryPolicy?.workingContext?.enabled !== false;
+}
+function resolveWorkingContextGate(workingMemory, memoryPolicy) {
+  const capability = resolveWorkingMemoryCapability(workingMemory);
+  if (capability === "disabled") {
+    return { ok: false, reason: "features.workingMemory=false" };
+  }
+  if (capability === "misconfigured") {
+    return { ok: false, reason: "features.workingMemory enabled without repository" };
+  }
+  if (!isWorkingContextPolicyEnabled(memoryPolicy)) {
+    return { ok: false, reason: "memoryPolicy.workingContext.enabled=false" };
+  }
+  return { ok: true };
+}
+function resolveWorkingMemoryCapability(workingMemory) {
+  if (typeof workingMemory === "string") {
+    return workingMemory;
+  }
+  return workingMemory.workingMemory ? "enabled" : "disabled";
+}
+
+// src/adapters/shared/injection/message-text.ts
+var MEMORY_HEADINGS = [
+  "## Previous session summary",
+  "## Recent session",
+  "## Agenr Session Recall",
+  "### Core Memory",
+  "### Relevant Durable Memory",
+  "## Agenr Before-Turn Recall",
+  "### Suggested Procedure"
+];
+function extractAgentMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      blocks.push(block);
+      continue;
+    }
+    if (!block || typeof block !== "object") {
+      continue;
+    }
+    const typed = block;
+    if (typeof typed.text === "string") {
+      blocks.push(typed.text);
+      continue;
+    }
+    const type = typeof typed.type === "string" ? typed.type.trim().toLowerCase() : "";
+    if (typeof typed.content === "string" && (type === "text" || type === "input_text" || type === "output_text")) {
+      blocks.push(typed.content);
+    }
+  }
+  return blocks.join("\n");
+}
+function extractRecentTurnsFromMessages(messages, options = {}) {
+  const turns = [];
+  for (const message of messages) {
+    const role = message.role === "user" || message.role === "assistant" ? message.role : void 0;
+    if (!role) {
+      continue;
+    }
+    const text = sanitizeRecentTurnText(extractAgentMessageText(message.content), role, options);
+    if (!text) {
+      continue;
+    }
+    turns.push({ role, text });
+  }
+  return turns;
+}
+function normalizePromptText(prompt, options = {}) {
+  let cleaned = stripAgenrMemoryContext(prompt);
+  if (options.stripInlineMetadata) {
+    cleaned = stripInlineMetadata(cleaned, options.inlineMetadataSentinels ?? []);
+  }
+  if (options.stripTimestampPrefix) {
+    cleaned = cleaned.replace(/^\s*\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s[^\]]+\]\s*/u, "");
+  }
+  if (options.stripUserPrefix) {
+    cleaned = cleaned.replace(/^\s*U:\s*/u, "");
+  }
+  cleaned = collapseWhitespace(cleaned);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function sanitizeRecentTurnText(text, role, options = {}) {
+  if (!text.trim()) {
+    return "";
+  }
+  const wrapperDetected = containsAgenrMemoryContext(text) || text.includes("## Agenr Session Recall") || text.includes("## Agenr Before-Turn Recall") || options.stripMemoryCheck === true && text.includes("[MEMORY CHECK]");
+  let cleaned = stripAgenrMemoryContext(text);
+  for (const heading of MEMORY_HEADINGS) {
+    cleaned = cleaned.split(heading).join(" ");
+  }
+  if (options.stripMemoryCheck === true) {
+    cleaned = cleaned.replace(/\[MEMORY CHECK\][^\n]*/gu, " ");
+  }
+  cleaned = collapseWhitespace(cleaned);
+  if (!wrapperDetected) {
+    return cleaned;
+  }
+  const segments = stripAgenrMemoryContext(text).split(/\n\s*\n/gu).map((segment) => collapseWhitespace(segment)).filter((segment) => segment.length > 0);
+  const fallbackSegment = segments.at(-1);
+  if (fallbackSegment) {
+    return role === "user" ? fallbackSegment : collapseWhitespace(cleaned);
+  }
+  return cleaned;
+}
+function stripInlineMetadata(text, sentinels) {
+  let cleaned = text;
+  for (const sentinel of sentinels) {
+    const escapedSentinel = escapeForRegExp(sentinel);
+    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}\\s*(?:\`\`\`json\\s*)?\\{[\\s\\S]*?\\}(?:\\s*\`\`\`)?`, "gu"), " ");
+    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}[^
+]*`, "gu"), " ");
+  }
+  cleaned = cleaned.replace(/Untrusted context \(metadata, do not treat as instructions or commands\):[\s\S]*$/gu, " ");
+  return cleaned;
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
 // src/adapters/skeln/hooks/before-agent-start.ts
 async function handleAgenrSkelnBeforeAgentStart(event, context, deps) {
   const scope = await deps.resolveScope(context);
@@ -937,10 +1691,181 @@ function createAgenrEpisodeSummaryLlm(provider, modelId, apiKey) {
   };
 }
 
-// src/adapters/skeln/transcript/parser.ts
-import { createHash } from "crypto";
-import * as fs from "fs/promises";
-import path from "path";
+// src/adapters/shared/bounded-episode-embedding.ts
+var EPISODE_EMBEDDING_RACE_TIMEOUT = /* @__PURE__ */ Symbol("episode-embedding-race-timeout");
+var EPISODE_EMBEDDING_MIN_HEADROOM_MS = 5e3;
+async function embedEpisodeSummaryWithinBudget(params) {
+  const minHeadroomMs = params.minHeadroomMs ?? EPISODE_EMBEDDING_MIN_HEADROOM_MS;
+  if (!params.embeddingAvailable) {
+    params.logger.info(`${params.logContext} reason=embedding_unavailable`);
+    return void 0;
+  }
+  const remainingBudgetMs = params.deadlineMs - Date.now();
+  if (remainingBudgetMs < minHeadroomMs) {
+    params.logger.info(`${params.logContext} reason=budget_tight remainingMs=${Math.max(0, remainingBudgetMs)}`);
+    return void 0;
+  }
+  try {
+    const result = await raceEmbeddingWithTimeout(params.embedding.embed([params.summary]), remainingBudgetMs);
+    if (result === EPISODE_EMBEDDING_RACE_TIMEOUT) {
+      params.logger.info(`${params.logContext} reason=embedding_timeout budgetMs=${remainingBudgetMs}`);
+      return void 0;
+    }
+    const vector = result[0]?.map((value) => Number.isFinite(value) ? value : 0);
+    if (!vector || vector.length === 0) {
+      params.logger.info(`${params.logContext} reason=empty_embedding`);
+      return void 0;
+    }
+    return vector;
+  } catch (error) {
+    params.logger.info(`${params.logContext} reason=${formatErrorMessage(error)}`);
+    return void 0;
+  }
+}
+async function raceEmbeddingWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      resolve(EPISODE_EMBEDDING_RACE_TIMEOUT);
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/adapters/shared/bounded-episode-summary.ts
+var EPISODE_SUMMARY_TIMEOUT_MS = 45e3;
+var EPISODE_SUMMARY_TIMEOUT_MESSAGE = "Episode summary generation timed out.";
+var EpisodeSummaryTimeoutError = class extends Error {
+  /**
+   * Creates a timeout error with a stable name for caller-side handling.
+   */
+  constructor() {
+    super(EPISODE_SUMMARY_TIMEOUT_MESSAGE);
+    this.name = "EpisodeSummaryTimeoutError";
+  }
+};
+async function raceEpisodeSummaryWithinTimeout(task, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      task,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new EpisodeSummaryTimeoutError()), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+// src/adapters/shared/bounded-episode-ingest-log.ts
+function logBoundedEpisodeTranscriptIngestOutcome(params) {
+  const prefix = `[agenr] ${params.actionLabel}`;
+  const fileField = params.fileField ?? "file";
+  const fileRef = `${fileField}=${params.filePath}`;
+  const countField = params.shortCountField ?? "materialTurns";
+  if (params.result.kind === "skipped") {
+    const skipped = params.result.skipped;
+    if (skipped.reason === "skipped_exists") {
+      params.logger.info(`${prefix} skipped for ${params.context} ${fileRef} reason=already_exists episode=${skipped.existingEpisode?.id}`);
+      return false;
+    }
+    if (skipped.reason === "skipped_short") {
+      params.logger.info(`${prefix} skipped for ${params.context} ${fileRef} reason=too_short ${countField}=${skipped.messageCount}`);
+      return false;
+    }
+    params.logger.info(`${prefix} skipped for ${params.context} ${fileRef} reason=${skipped.reason} ${countField}=${skipped.messageCount}`);
+    return false;
+  }
+  if (params.result.kind === "invalid") {
+    params.logger.info(`${prefix} skipped for ${params.context} ${fileRef} reason=invalid_transcript ${countField}=${params.result.invalid.messageCount}`);
+    return false;
+  }
+  const session = params.result.session;
+  if (session.action === "failed") {
+    if (session.error === EPISODE_SUMMARY_TIMEOUT_MESSAGE) {
+      params.logger.info(`${prefix} timed_out for ${params.context} ${fileRef} timeoutMs=${EPISODE_SUMMARY_TIMEOUT_MS}`);
+      return false;
+    }
+    if (session.error === "invalid_response" && params.failureModelRef) {
+      params.logger.info(`${prefix} failed for ${params.context} ${fileRef} reason=invalid_response model=${params.failureModelRef}`);
+      return false;
+    }
+    params.logger.info(`${prefix} failed for ${params.context} ${fileRef} reason=${session.error ?? "unknown"}`);
+    return false;
+  }
+  params.logger.info(`${prefix} ${session.action} for ${params.context} ${fileRef} episode=${session.episodeId}`);
+  return true;
+}
+
+// src/adapters/shared/bounded-episode-write.ts
+async function writeBoundedSingleTranscriptEpisode(params) {
+  const fileField = params.fileField ?? "file";
+  const fileRef = `${fileField}=${params.filePath}`;
+  try {
+    const ingestResult = await raceEpisodeSummaryWithinTimeout(
+      ingestEpisodeTranscript(params.filePath, params.ports, params.ingestOptions),
+      EPISODE_SUMMARY_TIMEOUT_MS
+    );
+    logBoundedEpisodeTranscriptIngestOutcome({
+      logger: params.logger,
+      actionLabel: params.actionLabel,
+      context: params.context,
+      filePath: params.filePath,
+      ...params.fileField ? { fileField: params.fileField } : {},
+      ...params.shortCountField ? { shortCountField: params.shortCountField } : {},
+      result: ingestResult,
+      ...params.failureModelRef ? { failureModelRef: params.failureModelRef } : {}
+    });
+  } catch (error) {
+    if (error instanceof EpisodeSummaryTimeoutError) {
+      params.logger.info(`[agenr] ${params.actionLabel} timed_out for ${params.context} ${fileRef} timeoutMs=${EPISODE_SUMMARY_TIMEOUT_MS}`);
+      return;
+    }
+    const message = formatErrorMessage(error);
+    if (params.unexpectedFailureLevel === "info") {
+      params.logger.info(`[agenr] ${params.actionLabel} failed for ${params.context} ${fileRef} reason=${message}`);
+      return;
+    }
+    params.logger.warn(`[agenr] ${params.actionLabel} failed for ${params.context} ${fileRef} reason=${message}`);
+  }
+}
+
+// src/adapters/shared/deadline-aware-episode-summary-llm.ts
+function createDeadlineAwareEpisodeSummaryLlm(baseLlm, deadlineMs) {
+  const usage = cloneUsageStats(baseLlm.metadata.usage);
+  const completeWithTimeout = async (task) => {
+    usage.calls += 1;
+    const remainingMs = Math.max(0, deadlineMs - Date.now());
+    return raceEpisodeSummaryWithinTimeout(task, remainingMs);
+  };
+  return {
+    complete: async (systemPrompt, userMessage) => completeWithTimeout(baseLlm.complete(systemPrompt, userMessage)),
+    completeJson: async (systemPrompt, userMessage) => completeWithTimeout(baseLlm.completeJson(systemPrompt, userMessage)),
+    metadata: {
+      ...baseLlm.metadata,
+      usage
+    }
+  };
+}
+function cloneUsageStats(usage) {
+  return { ...usage };
+}
+
+// src/adapters/skeln/transcript/parser.ts
+import { createHash } from "crypto";
+import * as fs from "fs/promises";
+import path from "path";
 var SkelnTranscriptParser = class {
   /**
    * Parses one Skeln session JSONL file into normalized transcript messages.
@@ -1176,44 +2101,1050 @@ async function writeSkelnShutdownEpisode(params) {
     skipDetails: `session=${params.target.sessionId}`
   });
 }
-
-// src/adapters/skeln/episode/shutdown-episode-write.ts
-function buildSkelnSessionShutdownEpisodeWork(params) {
-  const target = resolveSkelnSessionEpisodeTarget(params.context);
-  const shutdownWork = params.event.reason === "quit" ? writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger).finally(() => closeSkelnServicesAfterShutdown(params.servicesPromise)) : writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger);
-  return shutdownWork.catch((error) => {
-    logSkelnShutdownEpisodeFailure(error, params.logger);
-  });
+
+// src/adapters/skeln/episode/shutdown-episode-write.ts
+function buildSkelnSessionShutdownEpisodeWork(params) {
+  const target = resolveSkelnSessionEpisodeTarget(params.context);
+  const shutdownWork = params.event.reason === "quit" ? writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger).finally(() => closeSkelnServicesAfterShutdown(params.servicesPromise)) : writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger);
+  return shutdownWork.catch((error) => {
+    logSkelnShutdownEpisodeFailure(error, params.logger);
+  });
+}
+function scheduleSkelnSessionShutdownEpisodeWrite(params) {
+  const work = buildSkelnSessionShutdownEpisodeWork(params);
+  if (params.event.reason === "quit" && params.event.deferWork) {
+    params.event.deferWork(work);
+    return Promise.resolve();
+  }
+  if (params.event.reason === "quit") {
+    return work;
+  }
+  void work;
+  return Promise.resolve();
+}
+function logSkelnShutdownEpisodeFailure(error, logger) {
+  const log = logger ?? console;
+  log.warn(`[agenr] skeln shutdown episode failed: ${formatErrorMessage(error)}`);
+}
+async function closeSkelnServicesAfterShutdown(servicesPromise) {
+  try {
+    const services = await servicesPromise;
+    await services.close();
+  } catch {
+  }
+}
+async function writeScopedSkelnShutdownEpisode(servicesPromise, target, logger) {
+  const services = await servicesPromise;
+  if (!services.capabilities.shutdownEpisodes) {
+    return;
+  }
+  await writeSkelnShutdownEpisode({ target, services, logger });
+}
+
+// src/adapters/plugin-runtime/claim-extraction.ts
+function createClaimExtractionFromAgenrConfig(config) {
+  const claimExtractionConfig = resolveClaimExtractionConfig(config);
+  if (!claimExtractionConfig.enabled) {
+    return void 0;
+  }
+  try {
+    const { provider, modelId } = resolveModel(config, "claim");
+    const apiKey = resolveLlmApiKey(config, provider);
+    return {
+      llm: createLlmClient(provider, modelId, { apiKey }),
+      config: claimExtractionConfig
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/app/plugin-runtime/resolve-paths.ts
+function resolvePluginRuntimeConfig(config, resolvePath) {
+  const dbPathOverride = resolveOptionalPath(config.dbPath, resolvePath);
+  const configPathOverride = resolveOptionalPath(config.configPath, resolvePath);
+  const configPath = resolveConfigPath({
+    configPath: configPathOverride,
+    dbPath: dbPathOverride
+  });
+  const loadedConfig = readConfig({
+    configPath,
+    dbPath: dbPathOverride
+  });
+  const dbPath = dbPathOverride ?? resolveDbPath(loadedConfig);
+  return {
+    resolvedConfig: {
+      dbPath,
+      configPath
+    },
+    agenrConfig: {
+      ...loadedConfig,
+      dbPath
+    }
+  };
+}
+function resolveOptionalPath(value, resolvePath) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  return resolvePath ? resolvePath(normalized) : normalized;
+}
+
+// src/adapters/db/session-memory-repository.ts
+import { randomUUID } from "crypto";
+
+// src/app/working-memory/limits.ts
+function normalizeBoundedLimit(value, fallback, max) {
+  if (value === void 0 || !Number.isInteger(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.min(value, max);
+}
+function normalizeEventLimit(value) {
+  return normalizeBoundedLimit(value, 50, 200);
+}
+function normalizeListLimit(value) {
+  return normalizeBoundedLimit(value, 20, 100);
+}
+var CLOSE_EVENT_HISTORY_LIMIT = 1e3;
+
+// src/adapters/db/json.ts
+function serializeOptionalJson(value) {
+  return value === void 0 ? null : JSON.stringify(value);
+}
+function parseOptionalJson(value, label) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Failed to parse ${label}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+
+// src/app/session-memory/types.ts
+var SESSION_ARTIFACT_KINDS = ["continuity_summary", "recent_session", "compaction_checkpoint", "branch_abandonment", "session_episode"];
+var SESSION_LINEAGE_REASONS = ["fork", "clone", "resume", "subagent_spawn"];
+var SESSION_START_TRANSITION_REASONS = ["new", "unknown", ...SESSION_LINEAGE_REASONS];
+
+// src/adapters/db/session-memory-parsing.ts
+function parseSessionArtifactKind(value) {
+  if (SESSION_ARTIFACT_KINDS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported session artifact kind "${value}".`);
+}
+function parseSessionLineageReason(value) {
+  if (SESSION_LINEAGE_REASONS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported session lineage reason "${value}".`);
+}
+
+// src/adapters/db/session-memory-repository.ts
+var SESSION_LINEAGE_EDGE_SELECT_COLUMNS = `
+  id,
+  child_session_key,
+  parent_session_key,
+  parent_source_ref,
+  reason,
+  fork_entry_id,
+  fork_position,
+  observed_at
+`;
+var SESSION_ARTIFACT_SELECT_COLUMNS = `
+  id,
+  kind,
+  session_key,
+  source,
+  source_id,
+  source_ref,
+  content_hash,
+  summary,
+  metadata_json,
+  created_at,
+  expires_at
+`;
+function createSessionMemoryRepository(database) {
+  return {
+    upsertLineageEdge: (input) => upsertLineageEdge(database, input),
+    upsertSessionArtifact: (input) => upsertSessionArtifact(database, input),
+    recordTriggerIntake: (input) => recordTriggerIntake(database, input),
+    listSessionArtifacts: (filter) => listSessionArtifacts(database, filter),
+    listSessionArtifactsBySourceRef: (filter) => listSessionArtifactsBySourceRef(database, filter),
+    getLatestLineageEdgeForChild: (childSessionKey) => getLatestLineageEdgeForChild(database, childSessionKey)
+  };
+}
+async function upsertLineageEdge(database, input) {
+  return database.withTransaction(async (transaction) => upsertLineageEdgeWithExecutor(transaction, input));
+}
+async function recordTriggerIntake(database, input) {
+  return database.withTransaction(async (transaction) => {
+    const executor = transaction;
+    const result = {};
+    if (input.lineage) {
+      result.lineageEdge = await upsertLineageEdgeWithExecutor(executor, input.lineage);
+    }
+    if (input.artifact) {
+      result.artifact = await upsertSessionArtifact(executor, input.artifact);
+    }
+    return result;
+  });
+}
+async function upsertLineageEdgeWithExecutor(executor, input) {
+  const existing = await findMatchingLineageEdge(executor, input);
+  if (existing) {
+    return existing;
+  }
+  const id = randomUUID();
+  await executor.execute({
+    sql: `
+      INSERT INTO session_lineage_edges (
+        id,
+        child_session_key,
+        parent_session_key,
+        parent_source_ref,
+        reason,
+        fork_entry_id,
+        fork_position,
+        observed_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      id,
+      input.childSessionKey,
+      input.parentSessionKey ?? null,
+      input.parentSourceRef ?? null,
+      input.reason,
+      input.forkEntryId ?? null,
+      input.forkPosition ?? null,
+      input.observedAt
+    ]
+  });
+  const edge = await getLineageEdge(executor, id);
+  if (!edge) {
+    throw new Error(`Session lineage edge ${id} was not found after write.`);
+  }
+  return edge;
+}
+async function upsertSessionArtifact(executor, input) {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  await executor.execute({
+    sql: `
+      INSERT INTO session_artifacts (
+        id,
+        kind,
+        session_key,
+        source,
+        source_id,
+        source_ref,
+        content_hash,
+        summary,
+        metadata_json,
+        created_at,
+        expires_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(kind, source, source_id) DO UPDATE SET
+        session_key = excluded.session_key,
+        source_ref = excluded.source_ref,
+        content_hash = excluded.content_hash,
+        summary = excluded.summary,
+        metadata_json = excluded.metadata_json,
+        expires_at = excluded.expires_at
+    `,
+    args: [
+      randomUUID(),
+      input.kind,
+      input.sessionKey,
+      input.source,
+      input.sourceId,
+      input.sourceRef ?? null,
+      input.contentHash,
+      input.summary,
+      serializeOptionalJson(input.metadata),
+      createdAt,
+      input.expiresAt ?? null
+    ]
+  });
+  const artifact = await getSessionArtifactBySource(executor, input.kind, input.source, input.sourceId);
+  if (!artifact) {
+    throw new Error(`Session artifact ${input.kind}/${input.source}/${input.sourceId} was not found after write.`);
+  }
+  return artifact;
+}
+async function listSessionArtifacts(executor, filter) {
+  const sessionKey = filter.sessionKey.trim();
+  if (!sessionKey) {
+    return [];
+  }
+  return querySessionArtifacts(executor, {
+    conditions: ["session_key = ?"],
+    args: [sessionKey],
+    kinds: filter.kinds,
+    limit: filter.limit
+  });
+}
+async function listSessionArtifactsBySourceRef(executor, filter) {
+  const sourceRef = filter.sourceRef.trim();
+  if (!sourceRef) {
+    return [];
+  }
+  return querySessionArtifacts(executor, {
+    conditions: ["source_ref = ?"],
+    args: [sourceRef],
+    kinds: filter.kinds,
+    limit: filter.limit
+  });
+}
+async function getLatestLineageEdgeForChild(executor, childSessionKey) {
+  const normalizedChild = childSessionKey.trim();
+  if (!normalizedChild) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${SESSION_LINEAGE_EDGE_SELECT_COLUMNS}
+      FROM session_lineage_edges
+      WHERE child_session_key = ?
+      ORDER BY observed_at DESC, id ASC
+      LIMIT 1
+    `,
+    args: [normalizedChild]
+  });
+  const row = result.rows[0];
+  return row ? mapSessionLineageEdgeRow(row) : null;
+}
+async function findMatchingLineageEdge(executor, input) {
+  const parentSessionKeyClause = input.parentSessionKey ? "parent_session_key = ?" : "parent_session_key IS NULL";
+  const parentSourceRefClause = input.parentSourceRef ? "parent_source_ref = ?" : "parent_source_ref IS NULL";
+  const args = [
+    input.childSessionKey,
+    input.reason,
+    ...input.parentSessionKey ? [input.parentSessionKey] : [],
+    ...input.parentSourceRef ? [input.parentSourceRef] : []
+  ];
+  const result = await executor.execute({
+    sql: `
+      SELECT ${SESSION_LINEAGE_EDGE_SELECT_COLUMNS}
+      FROM session_lineage_edges
+      WHERE child_session_key = ?
+        AND reason = ?
+        AND ${parentSessionKeyClause}
+        AND ${parentSourceRefClause}
+      ORDER BY observed_at DESC, id ASC
+      LIMIT 1
+    `,
+    args
+  });
+  const row = result.rows[0];
+  return row ? mapSessionLineageEdgeRow(row) : null;
+}
+async function getLineageEdge(executor, id) {
+  const result = await executor.execute({
+    sql: `
+      SELECT ${SESSION_LINEAGE_EDGE_SELECT_COLUMNS}
+      FROM session_lineage_edges
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [id]
+  });
+  const row = result.rows[0];
+  return row ? mapSessionLineageEdgeRow(row) : null;
+}
+async function getSessionArtifactBySource(executor, kind, source, sourceId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT ${SESSION_ARTIFACT_SELECT_COLUMNS}
+      FROM session_artifacts
+      WHERE kind = ?
+        AND source = ?
+        AND source_id = ?
+      LIMIT 1
+    `,
+    args: [kind, source, sourceId]
+  });
+  const row = result.rows[0];
+  return row ? mapSessionArtifactRow(row) : null;
+}
+function appendKindFilter(conditions, args, kinds) {
+  if (kinds && kinds.length > 0) {
+    conditions.push(`kind IN (${kinds.map(() => "?").join(", ")})`);
+    args.push(...kinds);
+  }
+}
+async function querySessionArtifacts(executor, filter) {
+  const conditions = [...filter.conditions];
+  const args = [...filter.args];
+  appendKindFilter(conditions, args, filter.kinds);
+  const limit = normalizeBoundedLimit(filter.limit, 20, 100);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${SESSION_ARTIFACT_SELECT_COLUMNS}
+      FROM session_artifacts
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY created_at DESC, id ASC
+      LIMIT ?
+    `,
+    args: [...args, limit]
+  });
+  return result.rows.map((row) => mapSessionArtifactRow(row));
+}
+function mapSessionLineageEdgeRow(row) {
+  return {
+    id: readRequiredString(row, "id"),
+    childSessionKey: readRequiredString(row, "child_session_key"),
+    parentSessionKey: readOptionalString(row, "parent_session_key"),
+    parentSourceRef: readOptionalString(row, "parent_source_ref"),
+    reason: parseSessionLineageReason(readRequiredString(row, "reason")),
+    forkEntryId: readOptionalString(row, "fork_entry_id"),
+    forkPosition: readOptionalString(row, "fork_position"),
+    observedAt: readRequiredString(row, "observed_at")
+  };
+}
+function mapSessionArtifactRow(row) {
+  return {
+    id: readRequiredString(row, "id"),
+    kind: parseSessionArtifactKind(readRequiredString(row, "kind")),
+    sessionKey: readRequiredString(row, "session_key"),
+    source: readRequiredString(row, "source"),
+    sourceId: readRequiredString(row, "source_id"),
+    sourceRef: readOptionalString(row, "source_ref"),
+    contentHash: readRequiredString(row, "content_hash"),
+    summary: readRequiredString(row, "summary"),
+    metadata: parseOptionalJson(readOptionalString(row, "metadata_json"), "metadata_json"),
+    createdAt: readRequiredString(row, "created_at"),
+    expiresAt: readOptionalString(row, "expires_at")
+  };
+}
+
+// src/adapters/db/session-start-repository.ts
+function createSessionStartRepository(executor) {
+  return {
+    listCoreEntries: async (limit) => listCoreEntries(executor, limit)
+  };
+}
+async function listCoreEntries(executor, limit) {
+  if (limit <= 0) {
+    return [];
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE ${buildActiveEntryClause()}
+        AND expiry = 'core'
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [limit]
+  });
+  return result.rows.map((row) => mapEntryRow(row));
+}
+
+// src/adapters/db/working-memory-repository.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/app/working-memory/operations/manifest.ts
+var MODEL_VISIBLE_OPERATION_TYPES = [
+  "set_objective",
+  "replace_plan",
+  "merge_checkpoint",
+  "add_file_note",
+  "add_command_note",
+  "record_decision",
+  "record_assumption",
+  "set_next_actions",
+  "add_candidate"
+];
+var TRUSTED_HOST_ONLY_OPERATION_TYPES = ["configure_budget", "account_usage", "set_continuation_policy"];
+var HOST_ONLY_OPERATION_TYPES = ["set_status", ...TRUSTED_HOST_ONLY_OPERATION_TYPES];
+var WORKING_UPDATE_OPERATION_TYPES = [...MODEL_VISIBLE_OPERATION_TYPES, ...HOST_ONLY_OPERATION_TYPES];
+function isModelVisibleOperationType(type) {
+  return MODEL_VISIBLE_OPERATION_TYPES.includes(type);
+}
+function isTrustedHostOnlyWorkingOperation(type) {
+  return TRUSTED_HOST_ONLY_OPERATION_TYPES.includes(type);
+}
+
+// src/app/working-memory/constants.ts
+var OPEN_WORKING_SET_STATUSES = ["active", "paused", "blocked", "waiting", "needs_review", "budget_limited"];
+var CURRENT_WORKING_SET_STATUSES = [...OPEN_WORKING_SET_STATUSES, "complete"];
+var CLOSE_MANAGED_WORKING_SET_STATUSES = ["closed", "abandoned"];
+var TRUSTED_HOST_MUTATION_SOURCES = ["goal_command", "lifecycle_hook", "consolidation_job"];
+var WORKING_CANDIDATE_PROMOTION_STATUSES = ["pending", "promoted", "dismissed"];
+function isMutableWorkingSetStatus(status) {
+  return OPEN_WORKING_SET_STATUSES.includes(status);
+}
+function isCloseManagedStatus(status) {
+  return CLOSE_MANAGED_WORKING_SET_STATUSES.includes(status);
+}
+function isTrustedHostMutationSource(source) {
+  return source !== void 0 && TRUSTED_HOST_MUTATION_SOURCES.includes(source);
+}
+
+// src/adapters/db/working-memory-columns.ts
+var WORKING_SET_COLUMN_NAMES = [
+  "id",
+  "scope_key",
+  "scope_kind",
+  "title",
+  "objective",
+  "status",
+  "summary",
+  "snapshot_json",
+  "revision",
+  "project",
+  "session_id",
+  "conversation_key",
+  "cwd",
+  "git_root",
+  "git_branch",
+  "task_id",
+  "source",
+  "created_at",
+  "updated_at",
+  "last_active_at",
+  "closed_at",
+  "close_reason",
+  "episode_id"
+];
+var WORKING_SET_SELECT_COLUMNS = WORKING_SET_COLUMN_NAMES.join(",\n  ");
+var WORKING_SET_INSERT_COLUMNS = WORKING_SET_COLUMN_NAMES.join(",\n          ");
+var WORKING_SET_INSERT_PLACEHOLDERS = WORKING_SET_COLUMN_NAMES.map(() => "?").join(", ");
+var WORKING_SET_UPDATE_COLUMNS = [
+  "title",
+  "objective",
+  "status",
+  "summary",
+  "snapshot_json",
+  "revision",
+  "updated_at",
+  "last_active_at",
+  "closed_at",
+  "close_reason",
+  "episode_id"
+];
+var WORKING_SET_SEMANTIC_ONLY_UPDATE_COLUMNS = /* @__PURE__ */ new Set(["revision", "closed_at", "close_reason", "episode_id"]);
+var WORKING_SET_USAGE_PATCH_COLUMNS = WORKING_SET_UPDATE_COLUMNS.filter((column) => !WORKING_SET_SEMANTIC_ONLY_UPDATE_COLUMNS.has(column));
+var WORKING_EVENT_SELECT_COLUMNS = `
+  id,
+  working_set_id,
+  sequence,
+  event_type,
+  payload_json,
+  actor,
+  source,
+  host_event_id,
+  turn_id,
+  created_at
+`;
+function buildWorkingSetUpdateSetClause() {
+  return WORKING_SET_UPDATE_COLUMNS.map((column) => `${column} = ?`).join(",\n            ");
+}
+function buildWorkingSetUsagePatchSetClause() {
+  return WORKING_SET_USAGE_PATCH_COLUMNS.map((column) => `${column} = ?`).join(",\n            ");
+}
+function mapWorkingSetRow(row) {
+  const snapshot = parseJson(readRequiredString(row, "snapshot_json"), "snapshot_json");
+  return {
+    id: readRequiredString(row, "id"),
+    scopeKey: readRequiredString(row, "scope_key"),
+    scopeKind: readRequiredString(row, "scope_kind"),
+    title: readOptionalString(row, "title"),
+    objective: readOptionalString(row, "objective"),
+    status: readRequiredString(row, "status"),
+    summary: readOptionalString(row, "summary"),
+    snapshot,
+    revision: readNumber(row, "revision", 0),
+    project: readOptionalString(row, "project"),
+    sessionId: readOptionalString(row, "session_id"),
+    conversationKey: readOptionalString(row, "conversation_key"),
+    cwd: readOptionalString(row, "cwd"),
+    gitRoot: readOptionalString(row, "git_root"),
+    gitBranch: readOptionalString(row, "git_branch"),
+    taskId: readOptionalString(row, "task_id"),
+    source: readOptionalString(row, "source"),
+    createdAt: readRequiredString(row, "created_at"),
+    updatedAt: readRequiredString(row, "updated_at"),
+    lastActiveAt: readRequiredString(row, "last_active_at"),
+    closedAt: readOptionalString(row, "closed_at"),
+    closeReason: readOptionalString(row, "close_reason"),
+    episodeId: readOptionalString(row, "episode_id")
+  };
+}
+function mapWorkingEventRow(row) {
+  return {
+    id: readRequiredString(row, "id"),
+    workingSetId: readRequiredString(row, "working_set_id"),
+    sequence: readNumber(row, "sequence", 0),
+    eventType: readRequiredString(row, "event_type"),
+    payload: parseJson(readRequiredString(row, "payload_json"), "payload_json"),
+    actor: readOptionalString(row, "actor"),
+    source: readOptionalString(row, "source"),
+    hostEventId: readOptionalString(row, "host_event_id"),
+    turnId: readOptionalString(row, "turn_id"),
+    createdAt: readRequiredString(row, "created_at")
+  };
+}
+function parseJson(value, column) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in working-memory column ${column}: ${message}`, { cause: error });
+  }
+}
+
+// src/adapters/db/working-memory-repository.ts
+function createWorkingMemoryRepository(database) {
+  return {
+    getWorkingSet: (id) => getWorkingSet(database, id),
+    findCurrentWorkingSets: (scope) => findWorkingSetsByScope(database, scope, CURRENT_WORKING_SET_STATUSES),
+    listWorkingSets: (filter) => listWorkingSets(database, filter),
+    listWorkingEvents: (workingSetId, limit) => listWorkingEvents(database, workingSetId, limit),
+    createWorkingSet: (input) => createWorkingSet(database, input),
+    updateWorkingSet: (input) => updateWorkingSet(database, input),
+    patchWorkingSetUsage: (input) => patchWorkingSetUsage(database, input)
+  };
+}
+async function getWorkingSet(executor, id) {
+  const normalizedId = id.trim();
+  if (!normalizedId) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${WORKING_SET_SELECT_COLUMNS}
+      FROM working_sets
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [normalizedId]
+  });
+  const row = result.rows[0];
+  return row ? mapWorkingSetRow(row) : null;
+}
+async function findWorkingSetsByScope(executor, scope, statuses) {
+  const result = await executor.execute({
+    sql: `
+      SELECT ${WORKING_SET_SELECT_COLUMNS}
+      FROM working_sets
+      WHERE scope_key = ?
+        AND status IN (${statuses.map(() => "?").join(", ")})
+      ORDER BY last_active_at DESC, id ASC
+    `,
+    args: [scope.scopeKey, ...statuses]
+  });
+  return result.rows.map((row) => mapWorkingSetRow(row));
+}
+async function listWorkingSets(executor, filter) {
+  const conditions = [];
+  const args = [];
+  if (filter.scope) {
+    conditions.push("scope_key = ?");
+    args.push(filter.scope.scopeKey);
+  }
+  if (filter.statuses && filter.statuses.length > 0) {
+    conditions.push(`status IN (${filter.statuses.map(() => "?").join(", ")})`);
+    args.push(...filter.statuses);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = normalizeBoundedLimit(filter.limit, 20, 100);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${WORKING_SET_SELECT_COLUMNS}
+      FROM working_sets
+      ${where}
+      ORDER BY last_active_at DESC, id ASC
+      LIMIT ?
+    `,
+    args: [...args, limit]
+  });
+  return result.rows.map((row) => mapWorkingSetRow(row));
+}
+async function listWorkingEvents(executor, workingSetId, limit) {
+  const normalizedId = workingSetId.trim();
+  if (!normalizedId) {
+    return [];
+  }
+  const normalizedLimit = normalizeBoundedLimit(limit, 50, 1e3);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${WORKING_EVENT_SELECT_COLUMNS}
+      FROM working_events
+      WHERE working_set_id = ?
+      ORDER BY sequence DESC
+      LIMIT ?
+    `,
+    args: [normalizedId, normalizedLimit]
+  });
+  return result.rows.map((row) => mapWorkingEventRow(row)).reverse();
+}
+async function createWorkingSet(database, input) {
+  return database.withTransaction(async (transaction) => {
+    const executor = transaction;
+    const existing = await findWorkingSetsByScope(executor, input.scope, CURRENT_WORKING_SET_STATUSES);
+    if (existing.length > 0) {
+      return { kind: "active_set_exists", scopeKey: input.scope.scopeKey };
+    }
+    const id = randomUUID2();
+    const event = buildEvent({
+      workingSetId: id,
+      sequence: 1,
+      eventType: "created",
+      payload: {
+        objective: input.objective,
+        scope: input.scope
+      },
+      actor: input.actor,
+      source: input.source,
+      now: input.now
+    });
+    await executor.execute({
+      sql: `
+        INSERT INTO working_sets (
+          ${WORKING_SET_INSERT_COLUMNS}
+        )
+        VALUES (
+          ${WORKING_SET_INSERT_PLACEHOLDERS}
+        )
+      `,
+      args: [
+        id,
+        input.scope.scopeKey,
+        input.scope.scopeKind,
+        toNullableString(input.title),
+        toNullableString(input.objective),
+        input.status,
+        toNullableString(input.snapshot.summary),
+        serializeJson(input.snapshot),
+        1,
+        toNullableString(input.scope.project),
+        toNullableString(input.sessionId ?? input.scope.sessionId),
+        toNullableString(input.scope.conversationKey),
+        toNullableString(input.scope.cwd),
+        toNullableString(input.scope.gitRoot),
+        toNullableString(input.scope.gitBranch),
+        toNullableString(input.scope.taskId),
+        toNullableString(input.sourceLabel),
+        input.now,
+        input.now,
+        input.now,
+        null,
+        null,
+        null
+      ]
+    });
+    await insertWorkingEvent(executor, event);
+    const workingSet = await requireWorkingSet(executor, id);
+    return { workingSet, event };
+  });
+}
+async function updateWorkingSet(database, input) {
+  return database.withTransaction(async (transaction) => {
+    const executor = transaction;
+    const current = await getWorkingSet(executor, input.workingSetId);
+    if (!current) {
+      return { kind: "not_found" };
+    }
+    if (!canApplyWorkingSetUpdate(current.status, input.status)) {
+      return { kind: "terminal_status", status: current.status };
+    }
+    if (current.revision !== input.expectedRevision) {
+      return { kind: "revision_conflict", actualRevision: current.revision };
+    }
+    const nextRevision = current.revision + 1;
+    const event = buildEvent({
+      workingSetId: current.id,
+      sequence: nextRevision,
+      eventType: input.eventType,
+      payload: input.payload,
+      actor: input.actor,
+      source: input.source,
+      now: input.now
+    });
+    await executor.execute({
+      sql: `
+        UPDATE working_sets
+        SET ${buildWorkingSetUpdateSetClause()}
+        WHERE id = ?
+          AND revision = ?
+      `,
+      args: [
+        ...buildWorkingSetSnapshotUpdateArgs({
+          title: input.title,
+          objective: input.objective,
+          status: input.status,
+          snapshot: input.snapshot,
+          current
+        }),
+        nextRevision,
+        input.now,
+        input.now,
+        toNullableString(input.closedAt ?? current.closedAt),
+        toNullableString(input.closeReason ?? current.closeReason),
+        toNullableString(input.episodeId ?? current.episodeId),
+        current.id,
+        input.expectedRevision
+      ]
+    });
+    const workingSet = await requireWorkingSet(executor, current.id);
+    if (workingSet.revision !== nextRevision) {
+      return { kind: "revision_conflict", actualRevision: workingSet.revision };
+    }
+    await insertWorkingEvent(executor, event);
+    return { workingSet, event };
+  });
+}
+async function patchWorkingSetUsage(database, input) {
+  return database.withTransaction(async (transaction) => {
+    const executor = transaction;
+    const current = await getWorkingSet(executor, input.workingSetId);
+    if (!current) {
+      return { kind: "not_found" };
+    }
+    if (!canApplyWorkingSetUpdate(current.status, input.status)) {
+      return { kind: "terminal_status", status: current.status };
+    }
+    if (current.revision !== input.expectedRevision) {
+      return { kind: "revision_conflict", actualRevision: current.revision };
+    }
+    await executor.execute({
+      sql: `
+        UPDATE working_sets
+        SET ${buildWorkingSetUsagePatchSetClause()}
+        WHERE id = ?
+          AND revision = ?
+      `,
+      args: [
+        ...buildWorkingSetSnapshotUpdateArgs({
+          title: input.title,
+          objective: input.objective,
+          status: input.status,
+          snapshot: input.snapshot,
+          current
+        }),
+        input.now,
+        input.now,
+        current.id,
+        input.expectedRevision
+      ]
+    });
+    const workingSet = await requireWorkingSet(executor, current.id);
+    if (workingSet.revision !== input.expectedRevision) {
+      return { kind: "revision_conflict", actualRevision: workingSet.revision };
+    }
+    return { workingSet };
+  });
+}
+async function insertWorkingEvent(executor, event) {
+  await executor.execute({
+    sql: `
+      INSERT INTO working_events (
+        id,
+        working_set_id,
+        sequence,
+        event_type,
+        payload_json,
+        actor,
+        source,
+        host_event_id,
+        turn_id,
+        created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      event.id,
+      event.workingSetId,
+      event.sequence,
+      event.eventType,
+      serializeJson(event.payload),
+      toNullableString(event.actor),
+      toNullableString(event.source),
+      toNullableString(event.hostEventId),
+      toNullableString(event.turnId),
+      event.createdAt
+    ]
+  });
+}
+function buildWorkingSetSnapshotUpdateArgs(input) {
+  return [
+    toNullableString(input.title ?? input.current.title),
+    toNullableString(input.objective ?? input.snapshot.objective),
+    input.status,
+    toNullableString(input.snapshot.summary),
+    serializeJson(input.snapshot)
+  ];
+}
+function buildEvent(input) {
+  return {
+    id: randomUUID2(),
+    workingSetId: input.workingSetId,
+    sequence: input.sequence,
+    eventType: input.eventType,
+    payload: input.payload,
+    ...input.actor ? { actor: input.actor } : {},
+    ...input.source ? { source: input.source } : {},
+    createdAt: input.now
+  };
+}
+function canApplyWorkingSetUpdate(currentStatus, nextStatus) {
+  if (OPEN_WORKING_SET_STATUSES.includes(currentStatus)) {
+    return true;
+  }
+  return currentStatus === "complete" && CLOSE_MANAGED_WORKING_SET_STATUSES.includes(nextStatus);
+}
+async function requireWorkingSet(executor, id) {
+  const workingSet = await getWorkingSet(executor, id);
+  if (!workingSet) {
+    throw new Error(`Working set ${id} was not found after write.`);
+  }
+  return workingSet;
+}
+function serializeJson(value) {
+  return JSON.stringify(value);
+}
+function toNullableString(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : null;
 }
-function scheduleSkelnSessionShutdownEpisodeWrite(params) {
-  const work = buildSkelnSessionShutdownEpisodeWork(params);
-  if (params.event.reason === "quit" && params.event.deferWork) {
-    params.event.deferWork(work);
-    return Promise.resolve();
+
+// src/adapters/plugin-runtime/embed-query.ts
+function createEmbedQuery(embedding, available) {
+  if (!available) {
+    return void 0;
   }
-  if (params.event.reason === "quit") {
-    return work;
+  return async (text) => {
+    const vectors = await embedding.embed([text]);
+    const vector = vectors[0];
+    if (!vector) {
+      throw new Error("Embedding provider returned no vector for the query.");
+    }
+    return vector;
+  };
+}
+
+// src/adapters/plugin-runtime/create-memory-runtime.ts
+async function createPluginMemoryRuntime(input) {
+  const embeddingStatus = resolveEmbeddingStatus(input.agenrConfig);
+  const database = await createDatabase(input.dbPath);
+  const embedding = embeddingStatus.available ? createEmbeddingClient(requireApiKey(embeddingStatus), embeddingStatus.model) : createUnavailableEmbeddingPort(embeddingStatus.error ?? "Embeddings are unavailable.");
+  const baseRecall = createRecallAdapter(database, embedding);
+  const recall2 = attachCrossEncoderPort(baseRecall, resolveCrossEncoder(input.agenrConfig));
+  const slotPolicies = input.slotPolicies;
+  let closed = false;
+  return {
+    entries: database,
+    episodes: database,
+    procedures: database,
+    memory: createMemoryRepository(database, {
+      claimSlotPolicyConfig: slotPolicies
+    }),
+    workingMemoryRepository: createWorkingMemoryRepository(database),
+    sessionMemoryRepository: createSessionMemoryRepository(database),
+    sessionStart: {
+      repository: createSessionStartRepository(database),
+      recall: recall2,
+      slotPolicyConfig: slotPolicies
+    },
+    beforeTurn: {
+      recall: recall2,
+      procedures: database,
+      embedQuery: createEmbedQuery(embedding, embeddingStatus.available),
+      slotPolicyConfig: slotPolicies
+    },
+    embedding,
+    recall: recall2,
+    claimExtraction: input.claimExtraction,
+    embeddingStatus: toPublicEmbeddingStatus(embeddingStatus),
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (input.onBeforeClose) {
+        await input.onBeforeClose();
+      }
+      await database.close();
+    }
+  };
+}
+function resolveEmbeddingStatus(config) {
+  const model = resolveEmbeddingModel(config);
+  try {
+    return {
+      available: true,
+      provider: "openai",
+      requestedProvider: "openai",
+      model,
+      apiKey: resolveEmbeddingApiKey(config)
+    };
+  } catch (error) {
+    return {
+      available: false,
+      provider: "unconfigured",
+      requestedProvider: "openai",
+      model,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  void work;
-  return Promise.resolve();
 }
-function logSkelnShutdownEpisodeFailure(error, logger) {
-  const log = logger ?? console;
-  log.warn(`[agenr] skeln shutdown episode failed: ${formatErrorMessage(error)}`);
+function toPublicEmbeddingStatus(status) {
+  return {
+    available: status.available,
+    provider: status.provider,
+    requestedProvider: status.requestedProvider,
+    model: status.model,
+    ...status.error ? { error: status.error } : {}
+  };
 }
-async function closeSkelnServicesAfterShutdown(servicesPromise) {
+function createUnavailableEmbeddingPort(errorMessage) {
+  return {
+    async embed() {
+      throw new Error(errorMessage);
+    }
+  };
+}
+function requireApiKey(status) {
+  if (!status.apiKey) {
+    throw new Error("Embedding API key is unavailable.");
+  }
+  return status.apiKey;
+}
+function resolveCrossEncoder(config) {
   try {
-    const services = await servicesPromise;
-    await services.close();
+    const apiKey = resolveCrossEncoderApiKey(config);
+    const { modelId } = resolveModel(config, "cross_encoder");
+    return createOpenAICrossEncoder({ apiKey, model: modelId });
   } catch {
+    return void 0;
   }
 }
-async function writeScopedSkelnShutdownEpisode(servicesPromise, target, logger) {
-  const services = await servicesPromise;
-  if (!services.capabilities.shutdownEpisodes) {
-    return;
-  }
-  await writeSkelnShutdownEpisode({ target, services, logger });
+
+// src/adapters/plugin-runtime/compose-host-services.ts
+async function composeHostPluginServices(input) {
+  const { resolvedConfig, agenrConfig } = resolvePluginRuntimeConfig(input.config, input.resolvePath);
+  const claimExtraction = input.resolveClaimExtraction ? await input.resolveClaimExtraction({ agenrConfig, hostConfig: input.config }) : void 0;
+  const runtimeServices = await createPluginMemoryRuntime({
+    dbPath: resolvedConfig.dbPath,
+    agenrConfig,
+    slotPolicies: input.readSlotPolicies?.(input.config),
+    claimExtraction,
+    onBeforeClose: input.onBeforeClose
+  });
+  return input.extend({
+    config: input.config,
+    resolvedConfig,
+    agenrConfig,
+    runtimeServices
+  });
 }
 
 // src/app/features/resolve.ts
@@ -2574,6 +4505,391 @@ function createSkelnSessionScopeTracker() {
   };
 }
 
+// src/adapters/shared/claim-support.ts
+function buildSessionSourceFile(session, prefix) {
+  const target = session.sessionKey ?? session.sessionId ?? session.agentId ?? "unknown";
+  return `${prefix}:${target}`;
+}
+function buildToolCallClaimSupport(session, prefix, toolName, observedAt) {
+  return {
+    claim_support_source_kind: "tool_call",
+    claim_support_locator: `${buildSessionSourceFile(session, prefix)}#${toolName}`,
+    claim_support_observed_at: observedAt,
+    claim_support_mode: "explicit"
+  };
+}
+
+// src/adapters/shared/memory-tools.ts
+function buildRecallToolServices(services) {
+  return {
+    episodes: services.episodes,
+    procedures: services.procedures,
+    recall: services.recall,
+    embeddingStatus: services.embeddingStatus,
+    embedQuery: services.beforeTurn.embedQuery
+  };
+}
+var STORE_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    type: {
+      type: "string",
+      enum: [...ENTRY_TYPES],
+      description: ENTRY_TYPE_DESCRIPTION
+    },
+    subject: {
+      type: "string",
+      description: "Short subject line future recall can match. Name the durable takeaway, person, system, rule, relationship, or milestone directly."
+    },
+    content: {
+      type: "string",
+      description: "What a fresh session should remember. Store the durable takeaway, not the activity log, canonical record, or transient progress snapshot."
+    },
+    importance: {
+      type: "integer",
+      minimum: 1,
+      maximum: 10,
+      description: "Importance from 1 to 10. Use 7 for normal durable memory, 9 for critical constraints, and 10 only rarely."
+    },
+    expiry: {
+      type: "string",
+      enum: ["core", "permanent", "temporary"],
+      description: EXPIRY_DESCRIPTION
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" },
+      description: "Optional tags for entities, systems, teams, or themes that should improve later recall."
+    },
+    sourceContext: {
+      type: "string",
+      description: "Optional provenance note explaining why this memory was stored or what situation produced it."
+    },
+    supersedes: {
+      type: "string",
+      description: "ID of an entry this replaces. The old entry will be marked as superseded."
+    },
+    claimKey: {
+      type: "string",
+      description: 'Slot key identifying the specific knowledge slot (entity/attribute format, e.g., "project_name/deploy_strategy" or "postgres/max_connections"). Entries with the same claim key are candidates for supersession.'
+    },
+    validFrom: {
+      type: "string",
+      description: "ISO 8601 timestamp for when this fact became true in the world."
+    },
+    validTo: {
+      type: "string",
+      description: "ISO 8601 timestamp for when this fact stopped being true."
+    }
+  },
+  required: ["type", "subject", "content"]
+};
+var RECALL_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    query: {
+      type: "string",
+      description: "What you need to remember. Use a focused natural-language query rather than a broad 'everything' search. Phrase prior-state asks directly, for example 'what was the previous approach' or 'what changed from X to Y'. Phrase procedural asks directly, for example 'how do I rotate credentials' or 'what steps should I follow'."
+    },
+    mode: {
+      type: "string",
+      enum: [...RECALL_MODES],
+      description: "Recall mode: auto routes between exact entry recall, historical-state recall, procedural recall, and episodes; entries forces semantic recall; episodes forces temporal or semantic session recall; procedures forces procedural recall."
+    },
+    limit: {
+      type: "integer",
+      minimum: 1,
+      maximum: 10,
+      description: "Maximum results to return. Lower this when you want a tighter shortlist."
+    },
+    threshold: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      description: "Minimum final score from 0 to 1. Raise this when you want fewer, higher-confidence matches."
+    },
+    budget: {
+      type: "integer",
+      minimum: 1,
+      description: "Approximate token budget applied after entry scoring. Omit when you do not want a budget cap."
+    },
+    types: {
+      type: "array",
+      items: {
+        type: "string",
+        enum: [...ENTRY_TYPES]
+      },
+      description: "Optional knowledge types to filter by, such as decision, preference, lesson, fact, milestone, or relationship."
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" },
+      description: "Optional tags to filter by once you already know the relevant entity, system, or theme."
+    },
+    asOf: {
+      type: "string",
+      description: "Optional reference time for current-vs-prior resolution. Supports ISO timestamps and natural-language date phrases."
+    }
+  },
+  required: ["query"]
+};
+var UPDATE_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      description: "Entry id to update. Provide exactly one of id or subject."
+    },
+    subject: {
+      type: "string",
+      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
+    },
+    importance: {
+      type: "integer",
+      description: "New importance from 1 to 10. Use 7 for normal durable memory and reserve 9 to 10 for rare critical entries."
+    },
+    expiry: {
+      type: "string",
+      description: UPDATE_EXPIRY_DESCRIPTION
+    },
+    claimKey: {
+      type: "string",
+      description: 'Slot key identifying the specific knowledge slot (entity/attribute format, e.g., "project_name/deploy_strategy" or "postgres/max_connections"). Entries with the same claim key are candidates for supersession.'
+    },
+    validFrom: {
+      type: "string",
+      description: "ISO 8601 timestamp for when this fact became true."
+    },
+    validTo: {
+      type: "string",
+      description: "ISO 8601 timestamp for when this fact stopped being true."
+    }
+  }
+};
+var FETCH_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      description: "Entry id to fetch. Provide exactly one of id or subject."
+    },
+    subject: {
+      type: "string",
+      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
+    }
+  }
+};
+function parseStoreToolParams(rawParams, reader) {
+  const params = asRecord(rawParams);
+  const type = parseEntryType(reader.readString(params, "type", { required: true, label: "type" }) ?? "");
+  return {
+    type,
+    subject: reader.readString(params, "subject", { required: true, label: "subject" }) ?? "",
+    content: reader.readString(params, "content", { required: true, label: "content" }) ?? "",
+    importance: reader.readNumber(params, "importance", { integer: true, strict: true }),
+    expiry: parseExpiry(reader.readString(params, "expiry")),
+    tags: normalizeStringArray(reader.readStringArray(params, "tags")),
+    sourceContext: reader.readString(params, "sourceContext"),
+    supersedes: reader.readString(params, "supersedes"),
+    claimKey: reader.readString(params, "claimKey", { trim: false }),
+    validFrom: reader.readString(params, "validFrom"),
+    validTo: reader.readString(params, "validTo")
+  };
+}
+function parseRecallToolParams(rawParams, reader) {
+  const params = asRecord(rawParams);
+  const budget = reader.readNumber(params, "budget", { integer: true, strict: true });
+  if (budget !== void 0 && budget <= 0) {
+    throw new Error("budget must be a positive integer.");
+  }
+  return {
+    query: reader.readString(params, "query", { required: true, label: "query" }) ?? "",
+    mode: parseRecallMode(reader.readString(params, "mode")),
+    limit: reader.readNumber(params, "limit", { integer: true, strict: true }),
+    threshold: reader.readNumber(params, "threshold", { strict: true }),
+    budget,
+    types: parseEntryTypes(reader.readStringArray(params, "types")),
+    tags: normalizeStringArray(reader.readStringArray(params, "tags")),
+    asOf: reader.readString(params, "asOf")
+  };
+}
+function parseUpdateToolParams(rawParams, reader) {
+  const params = asRecord(rawParams);
+  return {
+    id: reader.readString(params, "id"),
+    subject: reader.readString(params, "subject"),
+    importance: reader.readNumber(params, "importance", { integer: true, strict: true }),
+    expiry: parseExpiry(reader.readString(params, "expiry")),
+    claimKeyInput: reader.readString(params, "claimKey", { trim: false }),
+    validFrom: reader.readString(params, "validFrom"),
+    validTo: reader.readString(params, "validTo")
+  };
+}
+function parseFetchToolParams(rawParams, reader) {
+  const params = asRecord(rawParams);
+  return {
+    id: reader.readString(params, "id"),
+    subject: reader.readString(params, "subject")
+  };
+}
+async function runStoreMemoryTool(params, services, options) {
+  const result = await storeEntriesDetailed(
+    [
+      {
+        type: params.type,
+        subject: params.subject,
+        content: params.content,
+        ...params.importance !== void 0 ? { importance: params.importance } : {},
+        ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+        ...params.tags.length > 0 ? { tags: params.tags } : {},
+        ...params.supersedes ? { supersedes: params.supersedes } : {},
+        ...params.claimKey ? {
+          claim_key: params.claimKey,
+          claim_key_raw: params.claimKey,
+          ...buildToolCallClaimSupport(options.session, options.sourcePrefix, "agenr_store", (/* @__PURE__ */ new Date()).toISOString())
+        } : {},
+        ...params.validFrom ? { valid_from: params.validFrom } : {},
+        ...params.validTo ? { valid_to: params.validTo } : {},
+        source_file: buildSessionSourceFile(options.session, options.sourcePrefix),
+        source_context: params.sourceContext ?? options.defaultSourceContext,
+        ...options.session.project ? { project: options.session.project } : {}
+      }
+    ],
+    services.entries,
+    services.embedding,
+    {
+      ...services.claimExtraction ? {
+        claimExtraction: {
+          llm: services.claimExtraction.llm,
+          db: services.entries,
+          config: services.claimExtraction.config
+        }
+      } : {},
+      onWarning: options.onWarning
+    }
+  );
+  const storedEntry = await services.memory.findEntryBySubject(params.subject);
+  if (result.stored > 0) {
+    return okOutcome(`Stored "${params.subject}".`, {
+      status: "stored",
+      subject: params.subject,
+      entryId: storedEntry?.id,
+      result,
+      ...options.extraDetails
+    });
+  }
+  if (result.skipped > 0) {
+    return okOutcome(`Skipped "${params.subject}" because an active duplicate already exists.`, {
+      status: "skipped",
+      subject: params.subject,
+      entryId: storedEntry?.id,
+      result,
+      ...options.extraDetails
+    });
+  }
+  return failedOutcome(`Rejected "${params.subject}". Check the supplied type, content, and metadata.`, {
+    status: "failed",
+    subject: params.subject,
+    result,
+    ...options.extraDetails
+  });
+}
+async function runRecallMemoryTool(params, services, options = {}) {
+  return runUnifiedRecall(
+    {
+      text: params.query,
+      ...params.mode ? { mode: params.mode } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {},
+      ...params.threshold !== void 0 ? { threshold: params.threshold } : {},
+      ...params.budget !== void 0 ? { budget: params.budget } : {},
+      ...params.types.length > 0 ? { types: params.types } : {},
+      ...params.tags.length > 0 ? { tags: params.tags } : {},
+      ...params.asOf ? { asOf: params.asOf } : {},
+      ...options.sessionKey ? { sessionKey: options.sessionKey } : {}
+    },
+    {
+      database: services.episodes,
+      procedures: services.procedures,
+      recall: services.recall,
+      embeddingAvailable: services.embeddingStatus.available,
+      embeddingError: services.embeddingStatus.error,
+      claimSlotPolicyConfig: options.slotPolicyConfig,
+      debugLog: options.debugLog,
+      embedQuery: services.embedQuery,
+      recallOptions: {
+        slotPolicyConfig: options.slotPolicyConfig
+      }
+    }
+  );
+}
+async function runFetchMemoryTool(params, services, options = {}) {
+  const entry = await resolveTargetEntry(buildEntryMemoryResolverPorts(services), { id: params.id, subject: params.subject });
+  assertEntryFetchableContentLength(entry.content);
+  return okOutcome(formatFetchedEntryText(entry), buildFetchToolDetails(entry, options.extraDetails));
+}
+async function runUpdateMemoryTool(params, services, options) {
+  const claimSupport = params.claimKeyInput === void 0 ? void 0 : buildToolCallClaimSupport(options.session, options.sourcePrefix, "agenr_update", (/* @__PURE__ */ new Date()).toISOString());
+  const normalizedClaimKeyUpdate = params.claimKeyInput === void 0 ? void 0 : (() => {
+    try {
+      return normalizeManualClaimKeyUpdate({
+        claimKey: params.claimKeyInput,
+        rawClaimKey: params.claimKeyInput,
+        supportSourceKind: claimSupport?.claim_support_source_kind,
+        supportLocator: claimSupport?.claim_support_locator,
+        supportObservedAt: claimSupport?.claim_support_observed_at,
+        supportMode: claimSupport?.claim_support_mode
+      });
+    } catch {
+      throw new Error("claimKey must use canonical entity/attribute format.");
+    }
+  })();
+  const entry = await resolveTargetEntry(buildEntryMemoryResolverPorts(services), { id: params.id, subject: params.subject });
+  if (params.importance === void 0 && params.expiry === void 0 && normalizedClaimKeyUpdate === void 0 && params.validFrom === void 0 && params.validTo === void 0) {
+    throw new Error("Provide at least one update field: importance, expiry, claimKey, validFrom, or validTo.");
+  }
+  const mergedValidity = validateTemporalValidityRange(params.validFrom ?? entry.valid_from, params.validTo ?? entry.valid_to);
+  if (!mergedValidity.ok) {
+    throw new Error(mergedValidity.message);
+  }
+  const normalizedValidFrom = params.validFrom !== void 0 ? mergedValidity.value.validFrom : void 0;
+  const normalizedValidTo = params.validTo !== void 0 ? mergedValidity.value.validTo : void 0;
+  const updated = await services.entries.updateEntry(entry.id, {
+    ...params.importance !== void 0 ? { importance: params.importance } : {},
+    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+    ...normalizedClaimKeyUpdate?.updateFields ?? {},
+    ...params.validFrom !== void 0 ? { valid_from: normalizedValidFrom } : {},
+    ...params.validTo !== void 0 ? { valid_to: normalizedValidTo } : {}
+  });
+  if (!updated) {
+    return failedOutcome(`Entry ${entry.id} is not active, so it could not be updated.`, {
+      status: "failed",
+      entryId: entry.id,
+      ...options.failureDetails
+    });
+  }
+  return okOutcome(`Updated "${entry.subject}".`, {
+    status: "updated",
+    entryId: entry.id,
+    subject: entry.subject,
+    ...params.importance !== void 0 ? { importance: params.importance } : {},
+    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+    ...normalizedClaimKeyUpdate !== void 0 ? { claimKey: normalizedClaimKeyUpdate.claimKey } : {},
+    ...params.validFrom !== void 0 ? { validFrom: normalizedValidFrom } : {},
+    ...params.validTo !== void 0 ? { validTo: normalizedValidTo } : {},
+    ...options.successDetails
+  });
+}
+function okOutcome(text, details) {
+  return { text, details, failed: false };
+}
+function failedOutcome(text, details) {
+  return { text, details, failed: true };
+}
+
 // src/adapters/shared/param-readers.ts
 function readStringParam(params, key, options = {}) {
   const value = params[key];
@@ -2899,6 +5215,234 @@ function registerGoalAliasTool(skeln, servicesPromise, resolveScope, definition)
   });
 }
 
+// src/adapters/shared/recall-format.ts
+function formatUnifiedRecallResults(result) {
+  const lines = [
+    "Recall Route",
+    `requested=${result.routing.requested} detected=${result.routing.detectedIntent} queried=${result.routing.queried.join(", ") || "none"}`,
+    result.routing.reason,
+    ""
+  ];
+  if (result.timeWindow) {
+    lines.push("Resolved Time Window");
+    lines.push(`${result.timeWindow.start} -> ${result.timeWindow.end} (${result.timeWindow.timezone}) from ${JSON.stringify(result.timeWindow.resolvedFrom)}`);
+    lines.push("");
+  }
+  if (result.asOf) {
+    lines.push("As Of");
+    lines.push(result.asOf);
+    lines.push("");
+  }
+  if (result.routing.queried.includes("procedures") || result.procedure || result.procedureCandidates.length > 0 || result.procedureNotices.length > 0) {
+    appendProcedureMatches(lines, result);
+    lines.push("");
+  }
+  const renderEntriesFirst = result.routing.detectedIntent === "historical_state";
+  if (renderEntriesFirst) {
+    appendEntryMatches(lines, result);
+    lines.push("");
+    appendClaimTransitions(lines, result);
+    lines.push("");
+    appendEpisodeMatches(lines, result);
+  } else {
+    appendEpisodeMatches(lines, result);
+    lines.push("");
+    appendEntryMatches(lines, result);
+    lines.push("");
+    appendClaimTransitions(lines, result);
+  }
+  if (recallResultHasTruncatedEntryPreviews(result)) {
+    lines.push("");
+    lines.push("Fetch Guidance");
+    lines.push("One or more entry previews were truncated. Call agenr_fetch with id when exact stored wording is required.");
+  }
+  if (result.notices.length > 0) {
+    lines.push("");
+    lines.push("Notices");
+    for (const notice of result.notices) {
+      lines.push(`- ${notice}`);
+    }
+  }
+  return lines.join("\n");
+}
+function appendProcedureMatches(lines, result) {
+  lines.push("Procedure Matches");
+  if (!result.procedure && result.procedureCandidates.length === 0) {
+    lines.push("None.");
+  } else {
+    if (result.procedure) {
+      appendCanonicalProcedure(lines, result.procedure, result.procedureCandidates);
+    } else {
+      lines.push("Canonical procedure: none.");
+    }
+    const additionalCandidates = result.procedureCandidates.filter((candidate) => candidate.procedure.id !== result.procedure?.id);
+    if (additionalCandidates.length > 0) {
+      lines.push("Other Candidates");
+      for (const [index, candidate] of additionalCandidates.entries()) {
+        lines.push(
+          `${index + 1}. ${candidate.procedure.procedure_key} | ${candidate.procedure.title} | score ${candidate.score.toFixed(2)} | lexical=${candidate.scores.lexical.toFixed(2)} | vector=${candidate.scores.vector.toFixed(2)}`
+        );
+      }
+    }
+  }
+  if (result.procedureNotices.length > 0) {
+    lines.push("Procedure Notices");
+    for (const notice of result.procedureNotices) {
+      lines.push(`- ${notice}`);
+    }
+  }
+}
+function appendEntryMatches(lines, result) {
+  lines.push("Entry Matches");
+  if (result.projectedEntries.length === 0) {
+    lines.push("None.");
+    return;
+  }
+  for (const [familyIndex, family] of result.entryFamilies.entries()) {
+    lines.push(
+      family.claimKey ? `Family ${familyIndex + 1}. claim_key=${family.claimKey} | slot_policy=${family.slotPolicy} | primary=${family.primary.entryId} | subject=${family.subject}` : `Standalone ${familyIndex + 1}. ${family.primary.entryId} | subject=${family.subject}`
+    );
+    for (const [entryIndex, entry] of family.entries.entries()) {
+      const preview = buildEntryRecallPreview(entry.recall.entry.content);
+      lines.push(
+        `   ${entryIndex + 1}. ${entry.entryId} | ${entry.recall.entry.type} | ${entry.recall.entry.subject} | score ${entry.recall.score.toFixed(2)} | state=${entry.memoryState} | claim_status=${formatClaimStatus(entry.claimStatus)}`
+      );
+      lines.push(`      ${preview.contentPreview}`);
+      lines.push(`      content_chars=${preview.contentChars} preview_truncated=${preview.previewTruncated ? "true" : "false"}`);
+      lines.push(`      freshness=${entry.freshness.label}`);
+      const provenance = formatProjectedEntryProvenance(entry);
+      if (provenance) {
+        lines.push(`      provenance=${provenance}`);
+      }
+      lines.push(`      why_surfaced=${entry.whySurfaced.summary}`);
+    }
+  }
+}
+function appendEpisodeMatches(lines, result) {
+  lines.push("Episode Matches");
+  if (result.episodes.length === 0) {
+    lines.push("None.");
+    return;
+  }
+  for (const [index, episode] of result.episodes.entries()) {
+    lines.push(
+      `${index + 1}. ${episode.episode.id} | ${episode.episode.source} | ${episode.episode.startedAt} -> ${episode.episode.endedAt ?? episode.episode.startedAt} | score ${episode.score.toFixed(2)}`
+    );
+    lines.push(`   ${index < 3 ? episode.episode.summary.trim() : truncate(episode.episode.summary.trim(), ENTRY_PREVIEW_MAX_CHARS)}`);
+    lines.push(`   why_matched=${describeEpisodeMatch(episode)}`);
+  }
+}
+function appendCanonicalProcedure(lines, procedure, candidates) {
+  const leadCandidate = candidates.find((candidate) => candidate.procedure.id === procedure.id);
+  lines.push(
+    leadCandidate ? `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title} | score ${leadCandidate.score.toFixed(2)}` : `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title}`
+  );
+  lines.push(`   goal=${procedure.goal}`);
+  appendLabeledList(lines, "when_to_use", procedure.when_to_use);
+  appendLabeledList(lines, "when_not_to_use", procedure.when_not_to_use);
+  appendLabeledList(lines, "prerequisites", procedure.prerequisites);
+  lines.push("   steps");
+  for (const [index, step] of procedure.steps.entries()) {
+    lines.push(`   ${index + 1}. [${step.kind}] ${step.instruction}`);
+    const stepDetails = formatProcedureStepDetails(step);
+    if (stepDetails.length > 0) {
+      for (const detail of stepDetails) {
+        lines.push(`      ${detail}`);
+      }
+    }
+  }
+  appendLabeledList(lines, "verification", procedure.verification);
+  appendLabeledList(lines, "failure_modes", procedure.failure_modes);
+  lines.push("   sources");
+  for (const source of procedure.sources) {
+    lines.push(`   - ${formatProcedureSource(source)}`);
+  }
+}
+function appendClaimTransitions(lines, result) {
+  lines.push("Claim Transitions");
+  if (result.claimTransitions.length === 0) {
+    lines.push("None.");
+    return;
+  }
+  for (const [index, transition] of result.claimTransitions.entries()) {
+    lines.push(
+      `${index + 1}. family=${transition.claimKey ?? transition.familyKey} | slot_policy=${transition.slotPolicy}${transition.currentEntryId ? ` | current=${transition.currentEntryId}` : ""}${transition.priorEntryId ? ` | prior=${transition.priorEntryId}` : ""}`
+    );
+    lines.push(`   ${transition.summary}`);
+    if (transition.episodeContext) {
+      lines.push(
+        `   episode=${transition.episodeContext.episodeId} | ${transition.episodeContext.startedAt} -> ${transition.episodeContext.endedAt ?? transition.episodeContext.startedAt}`
+      );
+      lines.push(`   ${truncate(transition.episodeContext.summary.trim(), ENTRY_PREVIEW_MAX_CHARS)}`);
+    }
+  }
+}
+function appendLabeledList(lines, label, values) {
+  lines.push(`   ${label}`);
+  if (values.length === 0) {
+    lines.push("   - none");
+    return;
+  }
+  for (const value of values) {
+    lines.push(`   - ${value}`);
+  }
+}
+function formatProcedureStepDetails(step) {
+  switch (step.kind) {
+    case "run_command":
+      return [`command=${step.command}`];
+    case "read_reference":
+      return [`ref=${formatProcedureSource(step.ref)}`];
+    case "inspect_state":
+      return [step.target ? `target=${step.target}` : void 0, step.query ? `query=${step.query}` : void 0].filter(
+        (value) => value !== void 0
+      );
+    case "edit_file":
+      return [`path=${step.path}`, `edit=${step.edit}`];
+    case "ask_user":
+      return [`prompt=${step.prompt}`];
+    case "invoke_tool":
+      return [step.tool ? `tool=${step.tool}` : void 0, step.arguments ? `arguments=${JSON.stringify(step.arguments)}` : void 0].filter(
+        (value) => value !== void 0
+      );
+    case "verify":
+      return step.checks.map((check) => `check=${check}`);
+    default:
+      return [];
+  }
+}
+function formatProcedureSource(source) {
+  const parts = [source.kind, source.label, source.path, source.locator].filter((value) => Boolean(value && value.length > 0));
+  return parts.join(" | ");
+}
+function describeEpisodeMatch(result) {
+  if (result.scores.semantic > 0 && result.scores.temporal > 0) {
+    return "Semantic match within the resolved time window.";
+  }
+  if (result.scores.semantic > 0) {
+    return "Semantic match to the episode summary.";
+  }
+  if (result.scores.temporal > 0) {
+    return "Session overlaps the resolved time window.";
+  }
+  return "Matched episodic recall ranking.";
+}
+function formatClaimStatus(status) {
+  return status === "no_key" ? "no-key" : status;
+}
+function formatProjectedEntryProvenance(entry) {
+  const parts = [
+    entry.provenance.supersededById ? `superseded_by=${entry.provenance.supersededById}` : void 0,
+    entry.provenance.supersessionKind ? `kind=${entry.provenance.supersessionKind}` : void 0,
+    entry.provenance.supersessionReason ? `reason=${truncate(entry.provenance.supersessionReason, 120)}` : void 0,
+    entry.provenance.supportSourceKind ? `support=${entry.provenance.supportSourceKind}` : void 0,
+    entry.provenance.supportMode ? `support_mode=${entry.provenance.supportMode}` : void 0,
+    entry.provenance.supportObservedAt ? `observed=${entry.provenance.supportObservedAt}` : void 0,
+    entry.provenance.supportLocator ? `locator=${truncate(entry.provenance.supportLocator, 120)}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.join(" | ");
+}
+
 // src/adapters/skeln/tools/recall.ts
 function registerAgenrSkelnRecallTool(skeln, servicesPromise, resolveScope) {
   skeln.registerTool({
@@ -3898,11 +6442,11 @@ function registerAgenrSkelnSubagentFindingHooks(skeln, servicesPromise, resolveS
     return void 0;
   });
 }
-async function routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, buildEvent) {
+async function routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, buildEvent2) {
   try {
     const scope = await resolveScope(context);
     const services = await servicesPromise;
-    logSessionMemoryTriggerResult(await services.routeSessionMemoryTrigger(buildEvent(scope)));
+    logSessionMemoryTriggerResult(await services.routeSessionMemoryTrigger(buildEvent2(scope)));
   } catch (error) {
     console.warn(`[agenr] session-memory trigger failed: ${formatErrorMessage(error)}`);
   }