@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/chunk-NBS62ES5.js

@@ -0,0 +1,3012 @@
+import {
+  normalizeOptionalString
+} from "./chunk-OJSIZDZD.js";
+import {
+  CLOSE_MANAGED_WORKING_SET_STATUSES,
+  CURRENT_WORKING_SET_STATUSES,
+  OPEN_WORKING_SET_STATUSES,
+  WORKING_MEMORY_DISABLED_MESSAGE,
+  createFailure,
+  createWorkingContextStubProjection,
+  normalizeBoundedLimit
+} from "./chunk-NSLTJBUC.js";
+import {
+  CLAIM_KEY_DESCRIPTION,
+  ENTRY_TYPE_DESCRIPTION,
+  EXPIRY_DESCRIPTION,
+  RECALL_MODES,
+  RECALL_MODE_SCHEMA_DESCRIPTION,
+  UPDATE_EXPIRY_DESCRIPTION,
+  asRecord,
+  createDreamPort,
+  createMemoryRepository,
+  formatErrorMessage,
+  ingestEpisodeTranscript,
+  normalizeStringArray,
+  parseDurableKind,
+  parseDurableKinds,
+  parseExpiry,
+  parseRecallMode,
+  storeDurablesDetailed
+} from "./chunk-LDJN7CVU.js";
+import {
+  containsAgenrMemoryContext,
+  createSessionStartRepository,
+  formatInjectionEntryBodyLines,
+  formatInjectionEntryHeader,
+  listActiveAbstainDirectives,
+  listActiveSessionStartProactiveDirectives,
+  listActiveTopicProactiveDirectives,
+  stripAgenrMemoryContext,
+  wrapAgenrMemoryContext
+} from "./chunk-XFJ4S4G2.js";
+import {
+  ENTRY_PREVIEW_MAX_CHARS,
+  assertEntryFetchableContentLength,
+  attachCrossEncoderPort,
+  buildEntryRecallPreview,
+  buildFetchToolDetails,
+  buildMemoryToolWarningDetails,
+  createDatabase,
+  createEmbeddingClient,
+  createLlmClient,
+  createOpenAICrossEncoder,
+  createRecallAdapter,
+  formatFetchedEntryText,
+  formatMemoryToolOutcomeText,
+  readNumber,
+  readOptionalString,
+  readRequiredString,
+  recallResultHasTruncatedEntryPreviews,
+  resolveCrossEncoderApiKey,
+  resolveEmbeddingApiKey,
+  resolveEmbeddingModel,
+  resolveLlmApiKey,
+  resolveModel,
+  runUnifiedRecall,
+  truncate
+} from "./chunk-5TIP2EPP.js";
+import {
+  isEpisodeWriteInProgress,
+  resolveDurableProjectScope,
+  tryAcquireDreamingRunLock,
+  withEpisodeWriteGuard,
+  withHeldDreamingRunLock
+} from "./chunk-SOQW7356.js";
+import {
+  AGENR_FEATURE_FLAG_KEYS,
+  DEFAULT_AGENR_FEATURE_FLAGS,
+  DEFAULT_DREAMING_IMPORTANCE_THRESHOLD,
+  DEFAULT_DREAMING_MIN_INTERVAL_MINUTES,
+  DURABLE_KINDS,
+  normalizeManualClaimKeyUpdate,
+  parseDirectiveTrigger,
+  readConfig,
+  resolveClaimExtractionConfig,
+  resolveConfigPath,
+  resolveDbPath
+} from "./chunk-VTHBPXDQ.js";
+import {
+  validateTemporalValidityRange
+} from "./chunk-VBPYU7GO.js";
+
+// src/adapters/shared/session-memory-routing.ts
+function logSessionMemoryTriggerResult(result) {
+  if (result.accepted || result.reason === "feature_disabled") {
+    return;
+  }
+  console.warn(`[agenr] session-memory trigger rejected: ${result.reason} (${result.message})`);
+}
+async function routeSessionMemoryTriggerSafely(params) {
+  try {
+    const scope = await params.resolveScope();
+    logSessionMemoryTriggerResult(await params.routeTrigger(scope));
+  } catch (error) {
+    console.warn(`[agenr] session-memory trigger failed: ${formatErrorMessage(error)}`);
+  }
+}
+function createSessionMemoryTriggerRouter(servicesPromise, buildEvent2) {
+  return async (scope) => {
+    const services = await servicesPromise;
+    return services.routeSessionMemoryTrigger(buildEvent2(scope));
+  };
+}
+
+// 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();
+  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
+      };
+    }
+  };
+}
+
+// src/app/plugin-runtime/session-lifecycle-intake.ts
+function createSessionLifecycleIntakeTracker() {
+  const pendingBySession = /* @__PURE__ */ new Map();
+  return {
+    track(sessionId, sessionKey, work) {
+      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
+      if (!identityKey) {
+        return work;
+      }
+      const tracked = work.finally(() => {
+        if (pendingBySession.get(identityKey) === tracked) {
+          pendingBySession.delete(identityKey);
+        }
+      });
+      pendingBySession.set(identityKey, tracked);
+      return tracked;
+    },
+    async wait(sessionId, sessionKey) {
+      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
+      if (!identityKey) {
+        return;
+      }
+      const pending = pendingBySession.get(identityKey);
+      if (pending) {
+        await pending;
+      }
+    },
+    async clear(sessionId, sessionKey) {
+      await this.wait(sessionId, sessionKey);
+      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
+      if (identityKey) {
+        pendingBySession.delete(identityKey);
+      }
+    }
+  };
+}
+
+// src/adapters/shared/compaction-prompt-tracker.ts
+function createCompactionPromptTracker() {
+  const injectedBySession = /* @__PURE__ */ new Map();
+  return {
+    shouldInject(sessionId, sessionKey, artifactSourceId) {
+      const key = resolveTrackingKey(sessionId, sessionKey);
+      if (!key) {
+        return false;
+      }
+      return injectedBySession.get(key) !== artifactSourceId;
+    },
+    markInjected(sessionId, sessionKey, artifactSourceId) {
+      const key = resolveTrackingKey(sessionId, sessionKey);
+      if (!key) {
+        return;
+      }
+      injectedBySession.set(key, artifactSourceId);
+    },
+    clear(sessionId, sessionKey) {
+      const key = resolveTrackingKey(sessionId, sessionKey);
+      if (!key) {
+        return;
+      }
+      injectedBySession.delete(key);
+    }
+  };
+}
+function resolveTrackingKey(sessionId, sessionKey) {
+  return resolveSessionIdentityKey(sessionId, sessionKey);
+}
+
+// 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 (!isRecord(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 episodesResult = normalizeEpisodeMemoryPolicyConfig(value.episodes);
+  if (!episodesResult.ok) {
+    errors.push(...episodesResult.errors);
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies", "sessionStart", "beforeTurn", "workingContext", "episodes"]);
+  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 || episodesResult.ok && episodesResult.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 } : {},
+      ...episodesResult.ok && episodesResult.value ? { episodes: episodesResult.value } : {}
+    } : void 0
+  };
+}
+function normalizeWorkingContextMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord(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 normalizeEpisodeMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["memoryPolicy.episodes must be an object when provided"] };
+  }
+  const errors = [];
+  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.episodes.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.episodes.${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 (!isRecord(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 (!isRecord(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 (!isRecord(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 (!isRecord(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 isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/adapters/shared/injection/merge-injection-content.ts
+function mergeInjectionContent(...parts) {
+  const merged = parts.map((part) => part?.trim()).filter((part) => Boolean(part)).join("\n\n");
+  return merged.length > 0 ? merged : void 0;
+}
+
+// src/adapters/shared/injection/session-start-format.ts
+function formatAgenrSessionStartRecall(patch) {
+  if (patch.durableMemory.length === 0) {
+    return "";
+  }
+  const lines = [];
+  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 profileEntries = patch.durableMemory.filter((item) => item.sourceKind === "profile");
+  if (profileEntries.length > 0) {
+    sections.push({ title: "Profile Memory", entries: profileEntries });
+  }
+  const directiveEntries = patch.durableMemory.filter((item) => item.sourceKind === "directive");
+  if (directiveEntries.length > 0) {
+    sections.push({ title: "Memory Directives", entries: directiveEntries });
+  }
+  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/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/shared/pre-compaction-episode.ts
+function scheduleGuardedEpisodeWrite(params) {
+  void withEpisodeWriteGuard({ port: params.dreaming, dbPath: params.dbPath }, params.write).catch(params.onFailure);
+}
+
+// src/adapters/shared/episode-write-policy.ts
+function isPluginEpisodeWriteEnabled(memoryPolicy) {
+  return memoryPolicy?.episodes?.enabled !== false;
+}
+
+// src/app/features/resolve.ts
+function resolveAgenrFeatureFlags(features) {
+  const resolved = { ...DEFAULT_AGENR_FEATURE_FLAGS };
+  for (const key of AGENR_FEATURE_FLAG_KEYS) {
+    if (features?.[key] !== void 0) {
+      resolved[key] = features[key];
+    }
+  }
+  return resolved;
+}
+
+// src/adapters/shared/injection/compaction-context.ts
+function formatCompactionRecallContext(artifact) {
+  const summary = artifact.summary.trim();
+  const metadata = readCompactionMetadata(artifact.metadata);
+  const lines = ["## Agenr Compaction Recall", summary];
+  if (metadata.compactedCount !== void 0 && metadata.messageCount !== void 0) {
+    lines.push(`${metadata.compactedCount} messages compacted, ${metadata.messageCount} remain in context.`);
+  } else if (metadata.tokensBefore !== void 0) {
+    lines.push(`Compacted from about ${metadata.tokensBefore.toLocaleString()} tokens.`);
+  }
+  return lines.join("\n");
+}
+function readCompactionMetadata(metadata) {
+  if (typeof metadata !== "object" || metadata === null) {
+    return {};
+  }
+  const record = metadata;
+  return {
+    ...readOptionalNumber(record.compactedCount) !== void 0 ? { compactedCount: readOptionalNumber(record.compactedCount) } : {},
+    ...readOptionalNumber(record.messageCount) !== void 0 ? { messageCount: readOptionalNumber(record.messageCount) } : {},
+    ...readOptionalNumber(record.tokensBefore) !== void 0 ? { tokensBefore: readOptionalNumber(record.tokensBefore) } : {}
+  };
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/adapters/shared/compaction-prompt-context.ts
+async function resolveCompactionPromptContext(params) {
+  const featureFlags = resolveAgenrFeatureFlags(params.features);
+  if (!featureFlags.sessionTreeCompaction || !params.sessionMemoryRepository) {
+    return void 0;
+  }
+  const artifacts = await params.sessionMemoryRepository.listSessionArtifacts({
+    sessionKey: params.sessionKey,
+    kinds: ["compaction_checkpoint"],
+    limit: 1
+  });
+  const artifact = artifacts[0];
+  if (!artifact || !params.tracker.shouldInject(params.sessionId, params.sessionKey, artifact.sourceId)) {
+    return void 0;
+  }
+  params.tracker.markInjected(params.sessionId, params.sessionKey, artifact.sourceId);
+  return formatCompactionRecallContext(artifact);
+}
+
+// src/app/session-memory/source-ref.ts
+var SESSION_FILE_SOURCE_REF_PREFIX = "session_file:";
+var COMPACTION_SOURCE_REF_PREFIX = "compaction:";
+var SESSION_END_SOURCE_REF_PREFIX = "session_end:";
+function buildSessionFileSourceRef(sessionFile) {
+  return `${SESSION_FILE_SOURCE_REF_PREFIX}${sessionFile.trim()}`;
+}
+function buildCompactionSourceRef(source) {
+  return `${COMPACTION_SOURCE_REF_PREFIX}${source.trim()}`;
+}
+function buildSessionEndSourceRef(source) {
+  return `${SESSION_END_SOURCE_REF_PREFIX}${source.trim()}`;
+}
+
+// src/app/dreaming/background-triggers.ts
+var MINUTE_MS = 60 * 1e3;
+async function maybeRunLightDream(input, deps) {
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const config = resolveLightDreamTriggerConfig(deps.config);
+  if (!config.lightEnabled) {
+    return { status: "skipped", reason: "light_disabled" };
+  }
+  if (input.trigger === "post_session" && !config.postSessionLightDream) {
+    return { status: "skipped", reason: "post_session_disabled" };
+  }
+  if (input.trigger === "importance" && isEpisodeWriteInProgress(deps.dbPath)) {
+    return { status: "skipped", reason: "episode_write_in_progress" };
+  }
+  const lock = await tryAcquireDreamingRunLock(deps.port, deps.dbPath);
+  if (!lock) {
+    return { status: "skipped", reason: "run_in_progress" };
+  }
+  return withHeldDreamingRunLock(lock, async (lease) => {
+    const [{ runDreamScan }, { runDreamWithHeldLock }] = await Promise.all([import("./scan-6JKPOQHD.js"), import("./service-EKFACEN6.js")]);
+    const lastRun = await deps.port.getLastRun();
+    if (isWithinMinInterval(lastRun, now(), config.minIntervalMinutes)) {
+      return { status: "skipped", reason: "interval_guard" };
+    }
+    const scan = await runDreamScan({ now }, { port: deps.port });
+    if (!hasEvidence(scan)) {
+      return { status: "skipped", reason: "no_evidence", unsynthesizedImportanceSum: scan.unsynthesizedImportanceSum };
+    }
+    if (input.trigger === "importance" && scan.unsynthesizedImportanceSum < config.importanceThreshold) {
+      return {
+        status: "skipped",
+        reason: "importance_below_threshold",
+        unsynthesizedImportanceSum: scan.unsynthesizedImportanceSum
+      };
+    }
+    const result = await runDreamWithHeldLock(
+      {
+        tier: "light",
+        apply: true,
+        verbose: false,
+        json: true,
+        skipBackup: true
+      },
+      {
+        port: deps.port,
+        dbPath: deps.dbPath,
+        config: deps.config,
+        now,
+        ...deps.embedding ? { embedding: deps.embedding } : {},
+        ...deps.createExtractLlm ? { createExtractLlm: deps.createExtractLlm } : {},
+        ...deps.createClaimExtractionLlm ? { createClaimExtractionLlm: deps.createClaimExtractionLlm } : {}
+      },
+      lease
+    );
+    return {
+      status: "ran",
+      result,
+      unsynthesizedImportanceSum: scan.unsynthesizedImportanceSum
+    };
+  });
+}
+function resolveLightDreamTriggerConfig(config) {
+  return {
+    lightEnabled: config?.dreaming?.tiers?.light?.enabled ?? true,
+    postSessionLightDream: config?.dreaming?.triggers?.postSessionLightDream ?? true,
+    importanceThreshold: config?.dreaming?.triggers?.importanceThreshold ?? DEFAULT_DREAMING_IMPORTANCE_THRESHOLD,
+    minIntervalMinutes: config?.dreaming?.triggers?.minIntervalMinutes ?? DEFAULT_DREAMING_MIN_INTERVAL_MINUTES
+  };
+}
+function isWithinMinInterval(lastRun, now, minIntervalMinutes) {
+  if (!lastRun || minIntervalMinutes <= 0) {
+    return false;
+  }
+  const reference = lastRun.completedAt ?? lastRun.startedAt;
+  const timestamp = Date.parse(reference);
+  if (!Number.isFinite(timestamp)) {
+    return false;
+  }
+  return now.getTime() - timestamp < minIntervalMinutes * MINUTE_MS;
+}
+function hasEvidence(scan) {
+  return scan.episodesSinceLastRun > 0 || scan.ingestFilesSinceLastRun > 0 || scan.durablesCreatedSinceLastRun > 0;
+}
+
+// src/adapters/plugin-runtime/claim-extraction.ts
+async function buildClaimExtractionRuntime(config, resolveLlm) {
+  const claimExtractionConfig = resolveClaimExtractionConfig(config);
+  if (!claimExtractionConfig.enabled) {
+    return void 0;
+  }
+  try {
+    return {
+      llm: await resolveLlm(),
+      config: claimExtractionConfig
+    };
+  } catch {
+    return void 0;
+  }
+}
+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/adapters/db/session-memory-repository.ts
+import { randomUUID } from "crypto";
+
+// 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 = ["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_durable_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_durable_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_durable_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/working-memory-repository.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// 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;
+}
+
+// src/adapters/plugin-runtime/embed-query.ts
+function createEmbedQuery(embedding, available) {
+  if (!available) {
+    return void 0;
+  }
+  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 recall = attachCrossEncoderPort(baseRecall, resolveCrossEncoder(input.agenrConfig));
+  const slotPolicies = input.slotPolicies;
+  const fetchActiveAbstainDirectives = () => listActiveAbstainDirectives(database);
+  const fetchSessionStartProactiveDirectives = () => listActiveSessionStartProactiveDirectives(database);
+  const fetchTopicProactiveDirectives = () => listActiveTopicProactiveDirectives(database);
+  const sessionMemoryRepository = createSessionMemoryRepository(database);
+  let closed = false;
+  return {
+    entries: database,
+    episodes: database,
+    procedures: database,
+    memory: createMemoryRepository(database, {
+      claimSlotPolicyConfig: slotPolicies
+    }),
+    dreaming: createDreamPort(database),
+    workingMemoryRepository: createWorkingMemoryRepository(database),
+    sessionMemoryRepository,
+    sessionStart: {
+      repository: createSessionStartRepository(database),
+      recall,
+      slotPolicyConfig: slotPolicies,
+      listActiveAbstainDirectives: fetchActiveAbstainDirectives,
+      listActiveProactiveDirectives: fetchSessionStartProactiveDirectives,
+      sessionMemoryRepository
+    },
+    beforeTurn: {
+      recall,
+      procedures: database,
+      embedQuery: createEmbedQuery(embedding, embeddingStatus.available),
+      slotPolicyConfig: slotPolicies,
+      listActiveAbstainDirectives: fetchActiveAbstainDirectives,
+      listActiveTopicProactiveDirectives: fetchTopicProactiveDirectives
+    },
+    embedding,
+    recall,
+    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)
+    };
+  }
+}
+function toPublicEmbeddingStatus(status) {
+  return {
+    available: status.available,
+    provider: status.provider,
+    requestedProvider: status.requestedProvider,
+    model: status.model,
+    ...status.error ? { error: status.error } : {}
+  };
+}
+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 apiKey = resolveCrossEncoderApiKey(config);
+    const { modelId } = resolveModel(config, "cross_encoder");
+    return createOpenAICrossEncoder({ apiKey, model: modelId });
+  } 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/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 await input.extend({
+    config: input.config,
+    resolvedConfig,
+    agenrConfig,
+    runtimeServices
+  });
+}
+
+// src/app/goal-continuation/service.ts
+var GOAL_CONTINUATION_FEATURE_DISABLED_MESSAGE = "Goal continuation is disabled by the goalContinuation feature flag.";
+var GOAL_CONTINUATION_HOST_MISSING_MESSAGE = "Goal continuation is host-owned; no host callback was registered for this Agenr runtime.";
+function createGoalContinuationService(featureFlags, hostPort) {
+  const featureEnabled = featureFlags.goalContinuation;
+  return {
+    async runCommand(params) {
+      if (!featureEnabled) {
+        return {
+          ok: false,
+          code: "feature_disabled",
+          message: GOAL_CONTINUATION_FEATURE_DISABLED_MESSAGE
+        };
+      }
+      if (!hostPort) {
+        return {
+          ok: false,
+          code: "host_callback_missing",
+          message: GOAL_CONTINUATION_HOST_MISSING_MESSAGE
+        };
+      }
+      return hostPort.runCommand(params);
+    }
+  };
+}
+
+// src/app/session-memory/trigger-router.ts
+import { createHash } from "crypto";
+var SESSION_MEMORY_TRIGGER_FLAGS = {
+  session_start: "sessionTreeLineage",
+  session_before_fork: "sessionTreeLineage",
+  session_before_compact: "sessionTreeCompaction",
+  session_compact: "sessionTreeCompaction",
+  session_before_tree: "sessionTreeCompaction",
+  session_tree: "sessionTreeLineage",
+  session_shutdown: "sessionTreeLineage"
+};
+var LINEAGE_REASONS = new Set(SESSION_LINEAGE_REASONS);
+async function routeSessionMemoryTrigger(event, featureFlags, deps = {}) {
+  const flagKey = SESSION_MEMORY_TRIGGER_FLAGS[event.type];
+  if (!featureFlags[flagKey]) {
+    return {
+      accepted: false,
+      reason: "feature_disabled",
+      message: `Session-memory trigger ${event.type} is disabled by feature flags.`
+    };
+  }
+  if (!deps.repository) {
+    return {
+      accepted: false,
+      reason: "misconfigured",
+      message: `Session-memory trigger ${event.type} is enabled, but no session-memory repository was wired into the runtime.`
+    };
+  }
+  const artifactInput = normalizeArtifactInput(event);
+  if (artifactInput.kind === "invalid") {
+    return invalidEvent(artifactInput.message);
+  }
+  const lineageInput = normalizeLineageInput(event);
+  if (lineageInput.kind === "invalid") {
+    return invalidEvent(lineageInput.message);
+  }
+  if (artifactInput.kind === "none" && lineageInput.kind === "none") {
+    return maybeAttachWorkingCheckpointRefresh(
+      event,
+      {
+        accepted: true,
+        action: isCheckpointRelevantTrigger(event.type) ? "checkpoint_relevant" : "no_lineage",
+        message: isCheckpointRelevantTrigger(event.type) ? `Session-memory trigger ${event.type} was accepted for checkpoint-relevant lifecycle handling.` : `Session-memory trigger ${event.type} did not include lineage or artifact facts.`
+      },
+      deps
+    );
+  }
+  const intakeInput = {
+    ...artifactInput.kind === "artifact" ? { artifact: artifactInput.input } : {},
+    ...lineageInput.kind === "lineage" ? { lineage: lineageInput.input } : {}
+  };
+  const intake = await deps.repository.recordTriggerIntake(intakeInput);
+  const artifact = intake.artifact;
+  const lineageEdge = intake.lineageEdge;
+  const action = resolveTriggerAction(artifact, lineageEdge);
+  return maybeAttachWorkingCheckpointRefresh(
+    event,
+    {
+      accepted: true,
+      action,
+      message: buildAcceptedMessage(event.type, action, artifact, lineageEdge),
+      ...lineageEdge ? { lineageEdge } : {},
+      ...artifact ? { artifact } : {}
+    },
+    deps
+  );
+}
+async function maybeAttachWorkingCheckpointRefresh(event, result, deps) {
+  if (!deps.workingMemoryEnabled) {
+    return result;
+  }
+  const { attachWorkingCheckpointRefresh } = await import("./lifecycle-checkpoint-IAC5FCQU.js");
+  return attachWorkingCheckpointRefresh(event, result, deps.workingMemory);
+}
+function normalizeLineageInput(event) {
+  if (!event.transitionReason || event.transitionReason === "new" || event.transitionReason === "unknown") {
+    return { kind: "none" };
+  }
+  if (!LINEAGE_REASONS.has(event.transitionReason)) {
+    return { kind: "invalid", message: `Unsupported session lineage reason "${event.transitionReason}".` };
+  }
+  const childSessionKey = normalizeOptionalString(event.childSessionKey) ?? normalizeOptionalString(event.sessionKey);
+  if (!childSessionKey) {
+    return { kind: "invalid", message: "Session lineage requires a child session key." };
+  }
+  const parentSessionKey = normalizeOptionalString(event.predecessor?.sessionKey);
+  const parentSourceRef = normalizeOptionalString(event.predecessor?.sourceRef);
+  if (!parentSessionKey && !parentSourceRef) {
+    return { kind: "none" };
+  }
+  const forkEntryId = normalizeOptionalString(event.predecessor?.forkEntryId);
+  const forkPosition = normalizeOptionalString(event.predecessor?.forkPosition);
+  return {
+    kind: "lineage",
+    input: {
+      childSessionKey,
+      ...parentSessionKey ? { parentSessionKey } : {},
+      ...parentSourceRef ? { parentSourceRef } : {},
+      reason: event.transitionReason,
+      ...forkEntryId ? { forkEntryId } : {},
+      ...forkPosition ? { forkPosition } : {},
+      observedAt: event.observedAt
+    }
+  };
+}
+function normalizeArtifactInput(event) {
+  if (!event.artifact) {
+    return { kind: "none" };
+  }
+  const sessionKey = normalizeOptionalString(event.artifact.sessionKey) ?? normalizeOptionalString(event.sessionKey);
+  if (!sessionKey) {
+    return { kind: "invalid", message: "Session artifact intake requires a session key." };
+  }
+  const source = normalizeOptionalString(event.artifact.source);
+  const sourceId = normalizeOptionalString(event.artifact.sourceId);
+  const summary = normalizeOptionalString(event.artifact.summary);
+  if (!source || !sourceId || !summary) {
+    return { kind: "invalid", message: "Session artifact intake requires source, sourceId, and summary." };
+  }
+  const contentHash = normalizeOptionalString(event.artifact.contentHash) ?? hashArtifactContent(event.artifact);
+  return {
+    kind: "artifact",
+    input: {
+      ...event.artifact,
+      sessionKey,
+      source,
+      sourceId,
+      summary,
+      contentHash
+    }
+  };
+}
+function hashArtifactContent(artifact) {
+  const payload = JSON.stringify({
+    kind: artifact.kind,
+    source: artifact.source,
+    sourceId: artifact.sourceId,
+    sourceRef: artifact.sourceRef,
+    summary: artifact.summary,
+    metadata: artifact.metadata
+  });
+  return createHash("sha256").update(payload).digest("hex");
+}
+function resolveTriggerAction(artifact, lineageEdge) {
+  if (artifact && lineageEdge) {
+    return "recorded";
+  }
+  if (artifact) {
+    return "artifact_recorded";
+  }
+  return "lineage_recorded";
+}
+function buildAcceptedMessage(triggerType, action, artifact, lineageEdge) {
+  if (action === "recorded" && artifact && lineageEdge) {
+    return `Session-memory trigger ${triggerType} recorded ${lineageEdge.reason} lineage edge ${lineageEdge.id} and ${artifact.kind} artifact ${artifact.id}.`;
+  }
+  if (action === "artifact_recorded" && artifact) {
+    return `Session-memory trigger ${triggerType} recorded ${artifact.kind} artifact ${artifact.id}.`;
+  }
+  if (lineageEdge) {
+    return `Session-memory trigger ${triggerType} recorded ${lineageEdge.reason} lineage edge ${lineageEdge.id}.`;
+  }
+  return `Session-memory trigger ${triggerType} was accepted.`;
+}
+function invalidEvent(message) {
+  return {
+    accepted: false,
+    reason: "invalid_event",
+    message
+  };
+}
+function isCheckpointRelevantTrigger(type) {
+  return type === "session_before_fork" || type === "session_before_compact" || type === "session_before_tree" || type === "session_shutdown";
+}
+
+// src/app/working-memory/disabled-service.ts
+function createDisabledWorkingMemoryService() {
+  const failure = () => createFailure("feature_disabled", WORKING_MEMORY_DISABLED_MESSAGE);
+  return {
+    async run(_params) {
+      return failure();
+    },
+    async prepareExternalGoalMutation(_params) {
+      return failure();
+    },
+    async renderProjection(input) {
+      const sourceRef = typeof input === "string" ? input : input.sourceRef;
+      return createWorkingContextStubProjection({
+        reason: "feature_disabled",
+        sourceRef
+      });
+    }
+  };
+}
+
+// src/app/host-memory/create-host-memory-services.ts
+async function createHostMemoryServices(featureFlags, options = {}) {
+  const workingMemory = featureFlags.workingMemory ? (await import("./service-RHNB5AEQ.js")).createWorkingMemoryService(featureFlags, {
+    repository: options.workingMemoryRepository,
+    sourceLabel: options.workingMemorySourceLabel
+  }) : createDisabledWorkingMemoryService();
+  return {
+    workingMemory,
+    goalContinuation: createGoalContinuationService(featureFlags, options.goalContinuationHostPort),
+    routeSessionMemoryTrigger: (event) => routeSessionMemoryTrigger(event, featureFlags, {
+      repository: options.sessionMemoryRepository,
+      workingMemoryEnabled: featureFlags.workingMemory,
+      workingMemory: featureFlags.workingMemory ? workingMemory : void 0
+    })
+  };
+}
+
+// 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/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/resolve-target.ts
+function buildEntryMemoryResolverPorts(services) {
+  return {
+    getDurableById: async (entryId) => await services.entries.getDurable(entryId) ?? (await services.memory.getEntryTrace(entryId))?.entry ?? null,
+    findEntryBySubject: async (subject) => services.memory.findEntryBySubject(subject)
+  };
+}
+async function resolveTargetDurable(ports, params) {
+  const id = readOptionalStringParam(params, "id");
+  const subject = readOptionalStringParam(params, "subject");
+  const selectorCount = (id ? 1 : 0) + (subject ? 1 : 0);
+  if (selectorCount !== 1) {
+    throw new Error("Provide exactly one target selector: id or subject.");
+  }
+  if (id) {
+    const entry2 = await ports.getDurableById(id);
+    if (!entry2) {
+      throw new Error(`No agenr entry found for id ${id}.`);
+    }
+    return entry2;
+  }
+  const entry = await ports.findEntryBySubject(subject ?? "");
+  if (!entry) {
+    throw new Error(`No agenr entry found for subject "${subject}".`);
+  }
+  return entry;
+}
+function readOptionalStringParam(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string.`);
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+
+// src/adapters/shared/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: [...DURABLE_KINDS],
+      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: CLAIM_KEY_DESCRIPTION
+    },
+    polarity: {
+      type: "string",
+      enum: ["abstain", "proactive"],
+      description: "Required when type is directive. Use abstain to suppress a topic or behavior; use proactive to surface the directive when its trigger fires."
+    },
+    trigger: {
+      type: "string",
+      description: "Optional when type is directive. Use session_start or always for proactive directives that should surface at session start; use topic:<term> for proactive directives that should surface during before-turn when the user mentions the topic; use always for abstain directives. Defaults to session_start for proactive directives and always for abstain directives."
+    },
+    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."
+    },
+    project: {
+      type: "string",
+      description: "Optional workspace or product slug when this memory is specifically about one repo or deployment. Omit for personal, family, and other cross-workspace facts even when the current session has a workspace."
+    }
+  },
+  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_SCHEMA_DESCRIPTION
+    },
+    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 durable scoring. Omit when you do not want a budget cap."
+    },
+    types: {
+      type: "array",
+      items: {
+        type: "string",
+        enum: [...DURABLE_KINDS]
+      },
+      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 durables."
+    },
+    expiry: {
+      type: "string",
+      description: UPDATE_EXPIRY_DESCRIPTION
+    },
+    claimKey: {
+      type: "string",
+      description: CLAIM_KEY_DESCRIPTION
+    },
+    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."
+    },
+    project: {
+      type: "string",
+      description: "Workspace or product slug for correcting memory scope/routing metadata. Use agenr_store with supersedes instead when the memory content, subject, type, or meaning changes."
+    }
+  }
+};
+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 = parseDurableKind(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 }),
+    polarity: parseDirectivePolarityParam(reader.readString(params, "polarity")),
+    trigger: parseDirectiveTriggerParam(reader.readString(params, "trigger")),
+    validFrom: reader.readString(params, "validFrom"),
+    validTo: reader.readString(params, "validTo"),
+    project: reader.readString(params, "project")
+  };
+}
+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: parseDurableKinds(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"),
+    project: reader.readString(params, "project")
+  };
+}
+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 sourceContext = params.sourceContext ?? options.defaultSourceContext;
+  const project = resolveDurableProjectScope(
+    {
+      project: params.project,
+      subject: params.subject,
+      content: params.content,
+      tags: params.tags,
+      source_context: sourceContext,
+      claim_key: params.claimKey
+    },
+    { sessionWorkspace: options.session.project }
+  );
+  const warnings = [];
+  const handleWarning = (warning) => {
+    warnings.push(warning);
+    options.onWarning?.(warning);
+  };
+  const result = await storeDurablesDetailed(
+    [
+      {
+        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.polarity ? { directive_polarity: params.polarity } : {},
+        ...params.trigger ? { directive_trigger: params.trigger } : {},
+        ...params.validFrom ? { valid_from: params.validFrom } : {},
+        ...params.validTo ? { valid_to: params.validTo } : {},
+        source_file: buildSessionSourceFile(options.session, options.sourcePrefix),
+        source_context: sourceContext,
+        ...project ? { project } : {}
+      }
+    ],
+    services.entries,
+    services.embedding,
+    {
+      ...services.claimExtraction ? {
+        claimExtraction: {
+          llm: services.claimExtraction.llm,
+          db: services.entries,
+          config: services.claimExtraction.config
+        }
+      } : {},
+      onWarning: handleWarning
+    }
+  );
+  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
+      },
+      warnings
+    );
+  }
+  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
+      },
+      warnings
+    );
+  }
+  return failedOutcome(
+    `Rejected "${params.subject}". Check the supplied type, content, and metadata.`,
+    {
+      status: "failed",
+      subject: params.subject,
+      result,
+      ...options.extraDetails
+    },
+    warnings
+  );
+}
+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 resolveTargetDurable(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 resolveTargetDurable(buildEntryMemoryResolverPorts(services), { id: params.id, subject: params.subject });
+  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 patch = buildUpdateMemoryToolPatch(params, normalizedClaimKeyUpdate, normalizedValidFrom, normalizedValidTo);
+  if (Object.keys(patch.dbFields).length === 0) {
+    throw new Error("Provide at least one update field.");
+  }
+  const updated = await services.entries.updateDurable(entry.id, patch.dbFields);
+  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,
+    ...patch.details,
+    ...options.successDetails
+  });
+}
+function buildUpdateMemoryToolPatch(params, normalizedClaimKeyUpdate, normalizedValidFrom, normalizedValidTo) {
+  const dbFields = {
+    ...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 } : {},
+    ...params.project !== void 0 ? { project: params.project } : {}
+  };
+  return {
+    dbFields,
+    details: {
+      ...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 } : {},
+      ...params.project !== void 0 ? projectDetailValue(params.project) : {}
+    }
+  };
+}
+function projectDetailValue(project) {
+  const trimmed = project.trim();
+  return { project: trimmed.length > 0 ? trimmed : null };
+}
+function okOutcome(text, details, warnings = []) {
+  return {
+    text: formatMemoryToolOutcomeText(text, warnings),
+    details: { ...details, ...buildMemoryToolWarningDetails(warnings) },
+    failed: false
+  };
+}
+function failedOutcome(text, details, warnings = []) {
+  return {
+    text: formatMemoryToolOutcomeText(text, warnings),
+    details: { ...details, ...buildMemoryToolWarningDetails(warnings) },
+    failed: true
+  };
+}
+function parseDirectivePolarityParam(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "abstain" || value === "proactive") {
+    return value;
+  }
+  throw new Error(`Unsupported directive polarity "${value}".`);
+}
+function parseDirectiveTriggerParam(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trigger = parseDirectiveTrigger(value);
+  if (!trigger) {
+    throw new Error(`Unsupported directive trigger "${value}".`);
+  }
+  return trigger;
+}
+
+// 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 durable 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("Durable 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(" | ");
+}
+
+export {
+  logSessionMemoryTriggerResult,
+  routeSessionMemoryTriggerSafely,
+  createSessionMemoryTriggerRouter,
+  resolveSessionIdentityKey,
+  createSessionStartTracker,
+  createSessionLifecycleIntakeTracker,
+  createCompactionPromptTracker,
+  normalizeOptionalBoolean,
+  normalizeOptionalPositiveInteger,
+  normalizePluginInjectionMemoryPolicyConfig,
+  mergeInjectionContent,
+  formatAgenrSessionStartRecall,
+  resolveSessionStartPolicy,
+  resolveBeforeTurnPolicy,
+  resolveWorkingContextGate,
+  extractRecentTurnsFromMessages,
+  normalizePromptText,
+  scheduleGuardedEpisodeWrite,
+  isPluginEpisodeWriteEnabled,
+  resolveAgenrFeatureFlags,
+  resolveCompactionPromptContext,
+  embedEpisodeSummaryWithinBudget,
+  EPISODE_SUMMARY_TIMEOUT_MS,
+  writeBoundedSingleTranscriptEpisode,
+  createDeadlineAwareEpisodeSummaryLlm,
+  buildSessionFileSourceRef,
+  buildCompactionSourceRef,
+  buildSessionEndSourceRef,
+  maybeRunLightDream,
+  buildClaimExtractionRuntime,
+  createClaimExtractionFromAgenrConfig,
+  createEmbedQuery,
+  composeHostPluginServices,
+  createHostMemoryServices,
+  buildRecallToolServices,
+  STORE_TOOL_PARAMETERS,
+  RECALL_TOOL_PARAMETERS,
+  UPDATE_TOOL_PARAMETERS,
+  FETCH_TOOL_PARAMETERS,
+  parseStoreToolParams,
+  parseRecallToolParams,
+  parseUpdateToolParams,
+  parseFetchToolParams,
+  runStoreMemoryTool,
+  runRecallMemoryTool,
+  runFetchMemoryTool,
+  runUpdateMemoryTool,
+  formatUnifiedRecallResults
+};