agenr 3.2.0 → 2026.6.2

package/dist/adapters/skeln/index.js

@@ -1,70 +1,95 @@
 import {
-  CLOSE_EVENT_HISTORY_LIMIT,
+  readGoalGeneration,
+  shouldInjectWorkingContext,
+  toWorkingContextAuditPointer
+} from "../../chunk-OWGQWQUP.js";
+import {
   EPISODE_SUMMARY_TIMEOUT_MS,
   FETCH_TOOL_PARAMETERS,
   RECALL_TOOL_PARAMETERS,
-  SESSION_LINEAGE_REASONS,
   STORE_TOOL_PARAMETERS,
   UPDATE_TOOL_PARAMETERS,
-  WORKING_CANDIDATE_PROMOTION_STATUSES,
+  buildCompactionSourceRef,
   buildRecallToolServices,
+  buildSessionFileSourceRef,
   composeHostPluginServices,
   createClaimExtractionFromAgenrConfig,
+  createCompactionPromptTracker,
   createDeadlineAwareEpisodeSummaryLlm,
+  createHostMemoryServices,
+  createSessionLifecycleIntakeTracker,
+  createSessionMemoryTriggerRouter,
   createSessionStartTracker,
   embedEpisodeSummaryWithinBudget,
   extractRecentTurnsFromMessages,
   formatAgenrSessionStartRecall,
   formatUnifiedRecallResults,
-  isCloseManagedStatus,
-  isModelVisibleOperationType,
-  isMutableWorkingSetStatus,
-  isTrustedHostMutationSource,
-  isTrustedHostOnlyWorkingOperation,
-  normalizeEventLimit,
-  normalizeListLimit,
-  normalizeOptionalString,
+  isPluginEpisodeWriteEnabled,
+  logSessionMemoryTriggerResult,
+  maybeRunLightDream,
+  mergeInjectionContent,
   normalizePluginInjectionMemoryPolicyConfig,
   normalizePromptText,
   parseFetchToolParams,
   parseRecallToolParams,
   parseStoreToolParams,
   parseUpdateToolParams,
+  resolveAgenrFeatureFlags,
   resolveBeforeTurnPolicy,
+  resolveCompactionPromptContext,
   resolveSessionIdentityKey,
   resolveSessionStartPolicy,
   resolveWorkingContextGate,
+  routeSessionMemoryTriggerSafely,
   runFetchMemoryTool,
   runRecallMemoryTool,
-  runSessionStart,
   runStoreMemoryTool,
   runUpdateMemoryTool,
+  scheduleGuardedEpisodeWrite,
   writeBoundedSingleTranscriptEpisode
-} from "../../chunk-KL6X2E3I.js";
+} from "../../chunk-NBS62ES5.js";
+import "../../chunk-OJSIZDZD.js";
+import {
+  WORKING_CANDIDATE_PROMOTION_STATUSES,
+  isModelVisibleOperationType
+} from "../../chunk-NSLTJBUC.js";
 import {
+  MEMORY_DOCTRINE,
+  MEMORY_RECALL_SECTION_HEADER,
   asRecord,
+  buildSkelnRecallToolDescription,
+  buildSkelnRecallToolGuidelines,
+  buildSkelnStoreToolDescription,
+  buildStoreToolGuidelines,
+  buildUpdateToolDescription,
+  buildUpdateToolGuidelines,
   createSingleTranscriptDiscoveryPort,
   formatErrorMessage,
   formatTargetSelector,
   sanitizeFetchToolParams,
   sanitizeUpdateToolParams
-} from "../../chunk-TMDNFBBC.js";
+} from "../../chunk-LDJN7CVU.js";
 import {
   formatAgenrBeforeTurnRecall,
-  runBeforeTurn
-} from "../../chunk-UEGURBBW.js";
+  runBeforeTurn,
+  runSessionStart
+} from "../../chunk-XFJ4S4G2.js";
 import {
-  AGENR_FEATURE_FLAG_KEYS,
-  DEFAULT_AGENR_FEATURE_FLAGS,
   buildRecallToolDetails,
   createLlmClient,
-  isRecord,
-  readOptionalFiniteNumber,
-  readOptionalTrimmedString,
   resolveLlmApiKey,
   resolveModel
-} from "../../chunk-FMQTRTWE.js";
-import "../../chunk-5LADPJ4C.js";
+} from "../../chunk-5TIP2EPP.js";
+import "../../chunk-GAERET5Q.js";
+import {
+  withEpisodeWriteGuard
+} from "../../chunk-SOQW7356.js";
+import {
+  isRecord,
+  readOptionalFiniteNumber,
+  readOptionalTrimmedString
+} from "../../chunk-VTHBPXDQ.js";
+import "../../chunk-VBPYU7GO.js";
 
 // src/adapters/skeln/config.ts
 function parseSkelnMemoryPolicyJson(raw) {
@@ -101,14 +126,16 @@ function mergeSkelnMemoryPolicy(fromSettings, fromOptions) {
   const sessionStart = fromSettings.sessionStart || fromOptions.sessionStart ? { ...fromSettings.sessionStart, ...fromOptions.sessionStart } : void 0;
   const beforeTurn = fromSettings.beforeTurn || fromOptions.beforeTurn ? { ...fromSettings.beforeTurn, ...fromOptions.beforeTurn } : void 0;
   const workingContext = fromSettings.workingContext || fromOptions.workingContext ? { ...fromSettings.workingContext, ...fromOptions.workingContext } : void 0;
-  if (!slotPolicies && !sessionStart && !beforeTurn && !workingContext) {
+  const episodes = fromSettings.episodes || fromOptions.episodes ? { ...fromSettings.episodes, ...fromOptions.episodes } : void 0;
+  if (!slotPolicies && !sessionStart && !beforeTurn && !workingContext && !episodes) {
     return void 0;
   }
   return {
     ...slotPolicies ? { slotPolicies } : {},
     ...sessionStart ? { sessionStart } : {},
     ...beforeTurn ? { beforeTurn } : {},
-    ...workingContext ? { workingContext } : {}
+    ...workingContext ? { workingContext } : {},
+    ...episodes ? { episodes } : {}
   };
 }
 function mergeSlotPolicies(fromSettings, fromOptions) {
@@ -128,183 +155,6 @@ function mergeSlotPolicies(fromSettings, fromOptions) {
   return { attributeHeads };
 }
 
-// src/app/working-memory/projection-render.ts
-var UTF8_BYTE_LENGTH = new TextEncoder();
-function byteLength(content) {
-  return UTF8_BYTE_LENGTH.encode(content).length;
-}
-function createWorkingContextStubProjection(input) {
-  const content = [
-    "<agenr_work_context>",
-    "Working memory is unavailable for this turn.",
-    `Reason: ${input.reason}`,
-    "Treat this as transient task-state metadata, not durable truth.",
-    "</agenr_work_context>"
-  ].join("\n");
-  return {
-    kind: "working_set",
-    renderMode: "stub",
-    content,
-    ...input.workingSetId ? { workingSetId: input.workingSetId } : {},
-    ...input.revision !== void 0 ? { revision: input.revision } : {},
-    sourceRef: input.sourceRef,
-    byteLength: byteLength(content)
-  };
-}
-function createWorkingContextFullProjection(workingSet, sourceRef) {
-  const snapshot = workingSet.snapshot;
-  const lines = [
-    "<agenr_work_context>",
-    "This is transient working memory for the current task, not durable truth.",
-    "It may be stale or hypothetical. Prefer current filesystem, git, tests, tool output, and the user's latest message for current-state claims.",
-    "",
-    `Scope: ${escapeText(workingSet.scopeKind)} ${escapeText(workingSet.scopeKey)}`,
-    `Working set: ${escapeText(workingSet.id)}`,
-    `Revision: ${workingSet.revision}`,
-    `Status: ${escapeText(workingSet.status)}`,
-    ...optionalLine("Objective", snapshot.objective ?? workingSet.title),
-    ...optionalLine("Summary", snapshot.summary),
-    ...renderStringList("Current plan", snapshot.currentPlan),
-    ...renderCheckpoint(snapshot.checkpoint?.summary),
-    ...renderNextActions(snapshot.nextActions),
-    ...renderLabeledNotes(
-      "Touched files",
-      snapshot.files,
-      (file) => file.path.trim().length > 0,
-      (file) => {
-        const note = file.note ? ` - ${escapeText(file.note)}` : "";
-        return `${escapeText(file.path)}${note}`;
-      }
-    ),
-    ...renderLabeledNotes(
-      "Recent commands",
-      snapshot.commands,
-      (command) => command.command.trim().length > 0,
-      (command) => {
-        const outcome = command.outcome ? ` - ${escapeText(command.outcome)}` : "";
-        return `${escapeText(command.command)}${outcome}`;
-      }
-    ),
-    ...renderLabeledNotes(
-      "Decisions",
-      snapshot.decisions,
-      (decision) => decision.decision.trim().length > 0,
-      (decision) => {
-        const rationale = decision.rationale ? ` - ${escapeText(decision.rationale)}` : "";
-        return `${escapeText(decision.decision)}${rationale}`;
-      }
-    ),
-    ...renderLabeledNotes(
-      "Assumptions",
-      snapshot.assumptions,
-      (assumption) => assumption.assumption.trim().length > 0,
-      (assumption) => {
-        const confidence = assumption.confidence ? ` [${assumption.confidence}]` : "";
-        const validated = assumption.validated === true ? " (validated)" : assumption.validated === false ? " (unvalidated)" : "";
-        return `${escapeText(assumption.assumption)}${confidence}${validated}`;
-      }
-    ),
-    ...renderStringList("Blockers", snapshot.blockers),
-    ...renderStringList("Open questions", snapshot.openQuestions),
-    ...renderCandidates(snapshot.candidates),
-    "",
-    "Rules:",
-    "- Update this working set when material task state changes.",
-    "- Leave a checkpoint before pausing, handing off, compacting, forking, or waiting.",
-    "- Do not close this working set; only the user clears goals with /goal clear.",
-    "- Do not store transient WIP with agenr_store.",
-    "- Promote only durable facts, decisions, preferences, or reusable procedures explicitly.",
-    "</agenr_work_context>"
-  ];
-  const content = lines.join("\n");
-  return {
-    kind: "working_set",
-    renderMode: "full",
-    content,
-    workingSetId: workingSet.id,
-    revision: workingSet.revision,
-    sourceRef,
-    byteLength: byteLength(content)
-  };
-}
-function escapeText(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function optionalLine(label, value) {
-  const normalized = value?.trim();
-  return normalized ? [`${label}: ${escapeText(normalized)}`] : [];
-}
-function renderStringList(title, values) {
-  const items = (values ?? []).map((value) => value.trim()).filter((value) => value.length > 0);
-  if (items.length === 0) {
-    return [];
-  }
-  return ["", `${title}:`, ...items.map((item) => `- ${escapeText(item)}`)];
-}
-function renderCheckpoint(summary) {
-  const normalized = summary?.trim();
-  return normalized ? ["", "Last checkpoint:", escapeText(normalized)] : [];
-}
-function renderLabeledNotes(title, items, isValid, formatLine) {
-  const filtered = (items ?? []).filter(isValid);
-  if (filtered.length === 0) {
-    return [];
-  }
-  return ["", `${title}:`, ...filtered.map((item) => `- ${formatLine(item)}`)];
-}
-function renderNextActions(actions) {
-  const items = (actions ?? []).filter((action) => action.text.trim().length > 0);
-  if (items.length === 0) {
-    return [];
-  }
-  return [
-    "",
-    "Next actions:",
-    ...items.map((action) => {
-      const status = action.status ? ` [${action.status}]` : "";
-      const ref = action.ref ? ` (${escapeText(action.ref)})` : "";
-      return `- ${escapeText(action.text)}${status}${ref}`;
-    })
-  ];
-}
-function renderCandidates(candidates) {
-  const pending = (candidates ?? []).filter((candidate) => candidate.promotionStatus === "pending");
-  if (pending.length === 0) {
-    return [];
-  }
-  return [
-    "",
-    "Pending memory candidates:",
-    ...pending.map((candidate) => {
-      if (candidate.kind === "episodic") {
-        return `- episodic: ${escapeText(candidate.summary)}`;
-      }
-      return `- ${candidate.kind}: ${escapeText(candidate.subject)}`;
-    })
-  ];
-}
-
-// src/app/working-memory/projection.ts
-function createToolSuccessProjection(workingSet, action, timestamp) {
-  return createWorkingContextFullProjection(workingSet, `agenr_work:${action}:${timestamp}`);
-}
-function shouldInjectWorkingContext(projection) {
-  return projection.renderMode === "full" && projection.content.trim().length > 0;
-}
-function toWorkingContextAuditPointer(projection) {
-  if (projection.workingSetId === void 0 || projection.revision === void 0) {
-    return void 0;
-  }
-  return {
-    source: "agenr_work",
-    workingSetId: projection.workingSetId,
-    revision: projection.revision,
-    sourceRef: projection.sourceRef,
-    bytes: projection.byteLength,
-    summary: projection.renderMode === "full" ? `Working set ${projection.workingSetId} rev ${projection.revision}` : `Working memory stub (${projection.sourceRef})`
-  };
-}
-
 // src/adapters/skeln/session/scope.ts
 function resolveSkelnSessionKey(sessionId, cwd) {
   const normalizedSessionId = sessionId.trim();
@@ -427,13 +277,14 @@ function isSkelnMessageEntry(entry) {
 // src/adapters/skeln/format/prompt-section.ts
 function buildAgenrSkelnMemoryPromptSection() {
   return [
-    "## Memory Recall",
-    "Before answering anything about prior work, decisions, preferences, people, dates, unfinished work, or past sessions, call agenr_recall first. Session-start recall is automatic, and conservative before-turn recall may also appear as injected background context; use agenr_recall mid-session when you need context you do not already have.",
-    "agenr_recall supports exact fact recall plus historical and episodic recall behind one tool: use mode=entries for exact facts, decisions, thresholds, and versions; use mode=auto for prior-state questions like what was the previous approach, what did we use before, or what changed from X to Y; use mode=episodes when you explicitly want session narrative recall.",
-    "agenr_recall returns truncated entry previews with ids, scores, and preview_truncated flags. Call agenr_fetch with id when preview_truncated=true or exact stored wording is required.",
-    "When Agenr injects memory automatically, treat it as non-user background context and use it silently when relevant rather than forcing it into the reply.",
-    "Use agenr_store for durable memory, not for logging. Store only the durable takeaway, standing rule, preference, risk, lesson, or relationship - not progress logs or data already canonical elsewhere.",
-    "Use agenr_update to correct metadata on an existing entry. Use agenr_store with supersedes for substantive content replacement.",
+    MEMORY_RECALL_SECTION_HEADER,
+    MEMORY_DOCTRINE.recall.first,
+    MEMORY_DOCTRINE.recall.modes,
+    MEMORY_DOCTRINE.recall.truncatedPreviewsWithFetch,
+    MEMORY_DOCTRINE.recall.injectedContext,
+    MEMORY_DOCTRINE.store.skelnNotLogging,
+    MEMORY_DOCTRINE.store.claimKeyPromptLine,
+    MEMORY_DOCTRINE.update.vsSupersedes,
     ""
   ];
 }
@@ -522,174 +373,276 @@ function traceSystemPromptDoctrineInjected(baseSystemPrompt, updatedSystemPrompt
   });
 }
 
-// src/adapters/skeln/hooks/before-agent-start.ts
-async function handleAgenrSkelnBeforeAgentStart(event, context, deps) {
-  const scope = await deps.resolveScope(context);
-  const doctrine = buildAgenrSkelnMemoryPromptSection().join("\n");
-  const systemPromptWithDoctrine = appendPromptSection(event.systemPrompt, doctrine);
-  const trackerState = deps.sessionStartTracker.consume(scope.sessionId, scope.sessionKey);
-  if (trackerState.isFirst) {
-    return resolveSessionStartInjection(scope, event.systemPrompt, systemPromptWithDoctrine, deps.servicesPromise);
-  }
-  return resolveBeforeTurnInjection(event, scope, event.systemPrompt, systemPromptWithDoctrine, context, deps.servicesPromise);
-}
-function buildAgenrSkelnInjectionMessage(content) {
+// src/adapters/shared/agenr-episode-summary-llm.ts
+function createAgenrEpisodeSummaryLlm(provider, modelId, apiKey) {
+  const client = createLlmClient(provider, modelId, { apiKey });
   return {
-    role: "user",
-    content: [{ type: "text", text: content }],
-    timestamp: Date.now()
+    complete: client.complete,
+    completeJson: client.completeJson,
+    metadata: {
+      modelRef: `${provider}/${modelId}`,
+      pricing: {
+        input: client.metadata.model.cost?.input ?? 0,
+        output: client.metadata.model.cost?.output ?? 0,
+        cacheRead: client.metadata.model.cost?.cacheRead ?? 0,
+        cacheWrite: client.metadata.model.cost?.cacheWrite ?? 0
+      },
+      usage: client.metadata.usage
+    }
   };
 }
-function appendPromptSection(systemPrompt, section) {
-  const trimmedSection = section.trim();
-  if (trimmedSection.length === 0 || systemPrompt.includes(trimmedSection)) {
-    return systemPrompt;
-  }
-  return `${systemPrompt.trimEnd()}
 
-${trimmedSection}`;
-}
-async function resolveSessionStartInjection(scope, baseSystemPrompt, systemPrompt, servicesPromise) {
-  let workingInjection;
-  try {
-    const services = await servicesPromise;
-    workingInjection = await resolveWorkingContextInjection(services, scope, `skeln:session-start:${scope.sessionKey}`);
-    if (services.skelnConfig.memoryPolicy?.sessionStart?.enabled === false) {
-      return composeSkelnBeforeAgentStartResult({
-        baseSystemPrompt,
-        systemPrompt,
-        recallKind: "session_start_recall",
-        recallSkippedReason: "memoryPolicy.sessionStart.enabled=false",
-        workingInjection
+// src/adapters/skeln/transcript/parser.ts
+import { createHash } from "crypto";
+import * as fs from "fs/promises";
+import path from "path";
+var SkelnTranscriptParser = class {
+  /**
+   * Parses one Skeln session JSONL file into normalized transcript messages.
+   *
+   * @param filePath - Absolute or relative Skeln session file.
+   * @returns Parsed transcript payload consumed by shared episode ingest.
+   */
+  async parseFile(filePath) {
+    const raw = await fs.readFile(filePath, "utf8");
+    const transcriptHash = createHash("sha256").update(raw).digest("hex");
+    const warnings = [];
+    const messages = [];
+    const records = parseJsonlRecords(raw, filePath, warnings);
+    const header = records[0] ? parseHeaderRecord(records[0], filePath, warnings) : {};
+    const sessionId = header.sessionId ?? deriveSkelnSessionIdFromFilePath(filePath);
+    const headerTimestamp = toIsoTimestamp(header.timestamp);
+    for (const record of records.slice(1)) {
+      if (record.type !== "message") {
+        continue;
+      }
+      const normalized = normalizeSkelnMessage(record.message);
+      if (!normalized) {
+        continue;
+      }
+      messages.push({
+        index: messages.length,
+        role: normalized.role,
+        text: normalized.text,
+        ...normalized.timestamp ? { timestamp: normalized.timestamp } : {}
       });
     }
-    const sessionStartPatch = await runSessionStart(
-      {
-        sessionKey: scope.sessionKey,
-        policy: resolveSessionStartPolicy(services.skelnConfig.memoryPolicy)
+    const startedAt = messages[0]?.timestamp ?? headerTimestamp;
+    const endedAt = messages.at(-1)?.timestamp;
+    return {
+      messages,
+      metadata: {
+        ...sessionId ? { sessionId } : {},
+        ...header.cwd ? { workingDirectory: header.cwd, project: path.basename(header.cwd) } : {},
+        ...startedAt ? { startedAt } : {},
+        ...endedAt ? { endedAt } : {},
+        messageCount: messages.length,
+        transcriptHash,
+        reconstructedSurface: "skeln",
+        surfaceReconstructionSource: "reconstructed",
+        sourceIdentity: path.resolve(filePath),
+        sourceIdentityKind: "skeln_session_file"
       },
-      services.sessionStart
-    );
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "session_start_recall",
-      recallText: formatAgenrSessionStartRecall(sessionStartPatch),
-      workingInjection
-    });
-  } catch (error) {
-    logInjectionFailure("session-start", scope, error);
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "session_start_recall",
-      recallFailureReason: error instanceof Error ? error.message : String(error),
-      workingInjection
-    });
-  }
-}
-async function resolveBeforeTurnInjection(event, scope, baseSystemPrompt, systemPrompt, context, servicesPromise) {
-  const services = await servicesPromise;
-  const workingInjection = await resolveWorkingContextInjection(services, scope, `skeln:before-turn:${scope.sessionKey}`);
-  if (services.skelnConfig.memoryPolicy?.beforeTurn?.enabled === false) {
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "before_turn_recall",
-      recallSkippedReason: "memoryPolicy.beforeTurn.enabled=false",
-      workingInjection
-    });
+      warnings
+    };
   }
-  const currentTurnText = normalizePromptText(event.prompt);
-  if (!currentTurnText) {
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "before_turn_recall",
-      recallSkippedReason: "empty turn prompt",
-      workingInjection
-    });
+};
+var skelnTranscriptParser = new SkelnTranscriptParser();
+function parseJsonlRecords(raw, filePath, warnings) {
+  const records = [];
+  const lines = raw.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      const record = isRecord(parsed) ? parsed : void 0;
+      if (!record) {
+        warnings.push(`Skipped non-object Skeln JSONL line ${index + 1} in ${filePath}.`);
+        continue;
+      }
+      records.push(record);
+    } catch (error) {
+      warnings.push(`Skipped malformed Skeln JSONL line ${index + 1} in ${filePath}: ${formatErrorMessage(error)}`);
+    }
   }
-  try {
-    const branchMessages = extractSkelnBeforeTurnBranchMessages(context.sessionManager.getBranch());
-    const beforeTurnPatch = await runBeforeTurn(
-      {
-        sessionKey: scope.sessionKey,
-        currentTurnText,
-        recentTurns: extractRecentTurnsFromMessages(branchMessages),
-        policy: resolveBeforeTurnPolicy(services.skelnConfig.memoryPolicy)
-      },
-      services.beforeTurn
-    );
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "before_turn_recall",
-      recallText: formatAgenrBeforeTurnRecall(beforeTurnPatch),
-      workingInjection
-    });
-  } catch (error) {
-    logInjectionFailure("before-turn", scope, error);
-    return composeSkelnBeforeAgentStartResult({
-      baseSystemPrompt,
-      systemPrompt,
-      recallKind: "before_turn_recall",
-      recallFailureReason: error instanceof Error ? error.message : String(error),
-      workingInjection
-    });
+  if (records.length === 0) {
+    warnings.push(`Skipped empty Skeln transcript file: ${filePath}`);
   }
+  return records;
 }
-function composeSkelnBeforeAgentStartResult(input) {
-  const recallText = input.recallText?.trim();
-  const memoryTrace = buildBeforeAgentStartMemoryTrace({
-    baseSystemPrompt: input.baseSystemPrompt,
-    systemPrompt: input.systemPrompt,
-    recallKind: input.recallKind,
-    recallText,
-    recallSkippedReason: input.recallSkippedReason,
-    recallFailureReason: input.recallFailureReason,
-    workingContextTrace: input.workingInjection?.trace
-  });
+function parseHeaderRecord(record, filePath, warnings) {
+  if (!record || record.type !== "session") {
+    warnings.push(`Skeln transcript ${filePath} is missing a session header.`);
+    return {};
+  }
   return {
-    systemPrompt: input.systemPrompt,
-    ...recallText ? { message: buildAgenrSkelnInjectionMessage(recallText) } : {},
-    ...input.workingInjection?.transientMessages ? { transientMessages: input.workingInjection.transientMessages } : {},
-    ...input.workingInjection?.workingContextAudit ? { workingContextAudit: input.workingInjection.workingContextAudit } : {},
-    ...memoryTrace.length > 0 ? { memoryTrace } : {}
+    sessionId: readOptionalTrimmedString(record.id),
+    timestamp: readOptionalFiniteNumber(record.timestamp),
+    cwd: readOptionalTrimmedString(record.cwd)
   };
 }
-async function resolveWorkingContextInjection(services, scope, sourceRef) {
-  const gate = resolveWorkingContextGate(services.capabilities.workingMemory, services.skelnConfig.memoryPolicy);
-  if (!gate.ok) {
-    return { trace: traceMemorySkipped("working_context", gate.reason) };
+function normalizeSkelnMessage(value) {
+  const message = isRecord(value) ? value : void 0;
+  if (!message) {
+    return void 0;
   }
-  return loadWorkingContextProjection(services, scope, sourceRef);
+  const role = normalizeRole(readOptionalTrimmedString(message.role));
+  if (!role) {
+    return void 0;
+  }
+  const text = normalizeMessageText(message.content);
+  if (!text) {
+    return void 0;
+  }
+  const timestamp = toIsoTimestamp(readOptionalFiniteNumber(message.timestamp));
+  return {
+    role,
+    text,
+    ...timestamp ? { timestamp } : {}
+  };
 }
-async function loadWorkingContextProjection(services, scope, sourceRef) {
-  try {
-    const projection = await services.workingMemory.renderProjection({
-      sourceRef,
-      scope: toWorkingScopeFromSkelnSession(scope)
-    });
-    if (!shouldInjectWorkingContext(projection)) {
-      const reason = projection.renderMode !== "full" ? "working projection stub" : "empty working projection";
-      return { trace: traceMemorySkipped("working_context", reason) };
+function normalizeRole(role) {
+  if (role === "user") {
+    return "user";
+  }
+  if (role === "assistant") {
+    return "assistant";
+  }
+  return void 0;
+}
+function normalizeMessageText(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  const parts = [];
+  for (const part of value) {
+    if (typeof part === "string") {
+      parts.push(part);
+      continue;
+    }
+    const record = isRecord(part) ? part : void 0;
+    const text = readOptionalTrimmedString(record?.text) ?? readOptionalTrimmedString(record?.content);
+    if (text) {
+      parts.push(text);
     }
-    const workingContextAudit = toWorkingContextAuditPointer(projection);
-    return {
-      transientMessages: [buildAgenrSkelnInjectionMessage(projection.content)],
-      ...workingContextAudit ? { workingContextAudit } : {},
-      trace: traceWorkingContextInjected(workingContextAudit, projection.content)
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`[agenr] working-context projection failed for session=${scope.sessionId} key=${scope.sessionKey}: ${message}`);
-    return { trace: traceMemoryFailed("working_context", message) };
   }
+  return parts.map((part) => part.trim()).filter(Boolean).join("\n").trim();
 }
-function logInjectionFailure(phase, scope, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.warn(`[agenr] ${phase} recall failed for session=${scope.sessionId} key=${scope.sessionKey}: ${message}`);
+function toIsoTimestamp(timestamp) {
+  if (timestamp === void 0) {
+    return void 0;
+  }
+  const date = new Date(timestamp);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function deriveSkelnSessionIdFromFilePath(filePath) {
+  const basename = path.basename(filePath).replace(/\.jsonl(?:\..*)?$/iu, "").trim();
+  return basename.length > 0 ? basename : void 0;
+}
+
+// src/adapters/skeln/episode/bounded-session-episode.ts
+function resolveSkelnSessionEpisodeTarget(context) {
+  return {
+    sessionId: String(context.sessionManager.getSessionId()),
+    sessionFile: resolveSessionFile(context)
+  };
+}
+async function writeSkelnBoundedSessionEpisode(params) {
+  const logger = params.logger ?? console;
+  const sessionFile = params.target.sessionFile;
+  const sessionId = params.target.sessionId;
+  const summaryDeadlineMs = Date.now() + EPISODE_SUMMARY_TIMEOUT_MS;
+  if (!sessionFile) {
+    logger.info(`[agenr] ${params.actionLabel} skipped for ${params.skipDetails} reason=no_session_file`);
+    return;
+  }
+  const episodeModel = resolveModel(params.services.agenrConfig, "episode");
+  const llmApiKey = resolveLlmApiKey(params.services.agenrConfig, episodeModel.provider);
+  const summaryLlm = createDeadlineAwareEpisodeSummaryLlm(
+    createAgenrEpisodeSummaryLlm(episodeModel.provider, episodeModel.modelId, llmApiKey),
+    summaryDeadlineMs
+  );
+  await writeBoundedSingleTranscriptEpisode({
+    filePath: sessionFile,
+    context: params.logContext,
+    actionLabel: params.actionLabel,
+    logger,
+    summaryDeadlineMs,
+    ports: {
+      files: createSingleTranscriptDiscoveryPort(sessionFile),
+      transcript: skelnTranscriptParser,
+      episodes: params.services.episodes,
+      createSummaryLlm: () => summaryLlm,
+      embedSummary: (summary) => embedEpisodeSummaryWithinBudget({
+        summary,
+        embedding: params.services.embedding,
+        embeddingAvailable: params.services.embeddingStatus.available,
+        deadlineMs: summaryDeadlineMs,
+        logger,
+        logContext: `[agenr] ${params.actionLabel} embedding skipped for ${params.logContext} file=${sessionFile}`
+      })
+    },
+    ingestOptions: {
+      source: "skeln",
+      genVersion: params.genVersion,
+      skipActiveSessionCheck: true,
+      ...params.activityThreshold ? { activityThreshold: params.activityThreshold } : {},
+      candidateOverrides: {
+        sessionId: params.sourceSessionId ?? sessionId,
+        sourceRef: params.buildSourceRef(sessionFile),
+        agentId: null,
+        surface: "skeln",
+        metadataSource: "reconstructed"
+      }
+    }
+  });
+}
+function resolveSessionFile(context) {
+  try {
+    const sessionFile = context.sessionManager.getSessionFile().trim();
+    return sessionFile || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/skeln/episode/episode-writer.ts
+var SKELN_EPISODE_GENERATOR_VERSION = "skeln-episodic-summary-v1";
+var SKELN_PHASE4_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD = {
+  minMaterialTurns: 8,
+  minDurationMs: 20 * 60 * 1e3
+};
+async function writeSkelnShutdownEpisode(params) {
+  await writeSkelnBoundedSessionEpisode({
+    target: params.target,
+    services: params.services,
+    logger: params.logger,
+    actionLabel: "skeln shutdown episode write",
+    genVersion: SKELN_EPISODE_GENERATOR_VERSION,
+    activityThreshold: SKELN_PHASE4_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD,
+    buildSourceRef: (sessionFile) => sessionFile,
+    logContext: `session=${params.target.sessionId} key=skeln:${params.target.sessionId}`,
+    skipDetails: `session=${params.target.sessionId}`
+  });
+}
+async function writeSkelnPreCompactionEpisode(params) {
+  await writeSkelnBoundedSessionEpisode({
+    target: params.target,
+    services: params.services,
+    logger: params.logger,
+    actionLabel: "skeln pre-compaction episode write",
+    genVersion: SKELN_EPISODE_GENERATOR_VERSION,
+    buildSourceRef: (sessionFile) => sessionFile,
+    sourceSessionId: `${params.target.sessionId}:pre-compaction:${params.messageCount}`,
+    logContext: `session=${params.target.sessionId}:pre-compaction:${params.messageCount}`,
+    skipDetails: `session=${params.target.sessionId}`
+  });
 }
 
 // src/adapters/skeln/hooks/session-memory.ts
@@ -722,10 +675,11 @@ function buildSkelnSessionBeforeForkTriggerEvent(scope, event) {
     observedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function buildSkelnSessionBeforeCompactTriggerEvent(scope) {
+function buildSkelnSessionBeforeCompactTriggerEvent(scope, event = {}) {
   return {
     type: "session_before_compact",
     sessionKey: scope.sessionKey,
+    ...Object.keys(event).length > 0 ? { payload: event } : {},
     observedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -781,12 +735,6 @@ function buildSkelnSessionShutdownTriggerEvent(scope, event) {
     observedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function logSessionMemoryTriggerResult(result) {
-  if (result.accepted || result.reason === "feature_disabled") {
-    return;
-  }
-  console.warn(`[agenr] session-memory trigger rejected: ${result.reason} (${result.message})`);
-}
 function resolveSessionStartTransitionReason(reason, previousSessionFile) {
   if (isLineageSessionStartReason(reason)) {
     return reason;
@@ -804,7 +752,7 @@ function buildSessionStartPredecessor(transitionReason, previousSessionFile) {
   if (!sourceRef) {
     return void 0;
   }
-  return { sourceRef };
+  return { sourceRef: buildSessionFileSourceRef(sourceRef) };
 }
 function buildCompactionCheckpointArtifact(sessionKey, compactionEntry, fromExtension) {
   return {
@@ -812,7 +760,7 @@ function buildCompactionCheckpointArtifact(sessionKey, compactionEntry, fromExte
     sessionKey,
     source: "skeln",
     sourceId: compactionEntry.id,
-    sourceRef: `compaction:${compactionEntry.id}`,
+    sourceRef: buildCompactionSourceRef(compactionEntry.id),
     summary: compactionEntry.summary,
     metadata: {
       firstKeptEntryId: compactionEntry.firstKeptEntryId,
@@ -821,1694 +769,437 @@ function buildCompactionCheckpointArtifact(sessionKey, compactionEntry, fromExte
   };
 }
 
-// src/adapters/skeln/hooks/subagent-findings.ts
-var SUBAGENT_OUTCOME_MAX_CHARS = 3e3;
-var SUBAGENT_RESULT_LIMIT = 6;
-async function recordSkelnSubagentFindings(servicesPromise, resolveScope, context, event) {
-  const commandNote = buildSkelnSubagentCommandNote(event, (/* @__PURE__ */ new Date()).toISOString());
-  if (!commandNote) {
+// src/adapters/skeln/hooks/session-memory-routing.ts
+async function routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, buildEvent) {
+  await routeSessionMemoryTriggerSafely({
+    resolveScope: () => resolveScope(context),
+    routeTrigger: createSessionMemoryTriggerRouter(servicesPromise, buildEvent)
+  });
+}
+
+// src/adapters/skeln/hooks/compaction-handlers.ts
+async function handleSkelnSessionBeforeCompact(event, context, servicesPromise, resolveScope) {
+  await routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeCompactTriggerEvent(scope, event));
+  await scheduleSkelnPreCompactionEpisodeWrite(event, context, servicesPromise);
+}
+async function resolveSkelnCompactionPromptContext(scope, services, tracker) {
+  return resolveCompactionPromptContext({
+    sessionId: scope.sessionId,
+    sessionKey: scope.sessionKey,
+    features: {
+      ...services.agenrConfig.features,
+      ...services.skelnConfig.featureFlags
+    },
+    sessionMemoryRepository: services.sessionMemoryRepository,
+    tracker
+  });
+}
+async function scheduleSkelnPreCompactionEpisodeWrite(event, context, servicesPromise) {
+  const target = resolveSkelnSessionEpisodeTarget(context);
+  if (!target.sessionFile) {
     return;
   }
   try {
-    const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
-    const result = await services.workingMemory.run({
-      action: "update",
-      scope: toWorkingScopeFromSkelnSession(scope),
-      operation: {
-        type: "add_command_note",
-        command: commandNote
-      },
-      updateReason: "Recorded bounded subagent findings on the parent working set.",
-      actor: "runtime",
-      source: "lifecycle_hook"
-    });
-    if (!result.ok && !isExpectedSubagentFindingSkip(result.code)) {
-      console.warn(`[agenr] subagent findings working-memory update failed: ${result.message}`);
+    const services = await servicesPromise;
+    if (!isPluginEpisodeWriteEnabled(services.skelnConfig.memoryPolicy)) {
+      return;
     }
+    const messageCount = resolveSkelnPreCompactionMessageCount(context, event);
+    scheduleGuardedEpisodeWrite({
+      dreaming: services.dreaming,
+      dbPath: services.config.dbPath,
+      write: async () => writeSkelnPreCompactionEpisode({
+        target,
+        messageCount,
+        services
+      }),
+      onFailure: (error) => {
+        console.warn(`[agenr] skeln pre-compaction episode write failed for session=${target.sessionId}: ${formatErrorMessage(error)}`);
+      }
+    });
   } catch (error) {
-    console.warn(`[agenr] subagent findings capture failed: ${formatErrorMessage(error)}`);
+    console.warn(`[agenr] skeln pre-compaction episode write skipped: ${formatErrorMessage(error)}`);
   }
 }
-function buildSkelnSubagentCommandNote(event, observedAt) {
-  if (event.toolName !== "subagent" || event.isError) {
-    return void 0;
+function resolveSkelnPreCompactionMessageCount(context, event) {
+  if (typeof event.messageCount === "number" && Number.isFinite(event.messageCount)) {
+    return event.messageCount;
   }
-  const details = isRecord(event.details) ? event.details : void 0;
-  if (!details) {
-    return void 0;
+  try {
+    return context.sessionManager.getBranch().length;
+  } catch {
+    return 0;
   }
-  const mode = readOptionalTrimmedString(details.mode) ?? "unknown";
-  const artifactPath = readOptionalTrimmedString(details.artifactPath);
-  const results = Array.isArray(details.results) ? details.results.flatMap(normalizeDelegationResult).slice(0, SUBAGENT_RESULT_LIMIT) : [];
-  if (results.length === 0 && !artifactPath) {
-    return void 0;
+}
+
+// src/adapters/skeln/hooks/before-agent-start.ts
+async function handleAgenrSkelnBeforeAgentStart(event, context, deps) {
+  const scope = await deps.resolveScope(context);
+  await deps.lifecycleIntakeTracker.wait(scope.sessionId, scope.sessionKey);
+  const doctrine = buildAgenrSkelnMemoryPromptSection().join("\n");
+  const systemPromptWithDoctrine = appendPromptSection(event.systemPrompt, doctrine);
+  const trackerState = deps.sessionStartTracker.consume(scope.sessionId, scope.sessionKey);
+  if (trackerState.isFirst) {
+    return resolveSessionStartInjection(scope, event.systemPrompt, systemPromptWithDoctrine, deps.servicesPromise);
   }
-  const resultLines = results.map(
-    (result) => `- ${result.agent}${result.name ? `/${result.name}` : ""}: ${result.status}${result.summary ? ` - ${result.summary}` : ""}`
-  );
-  const outcome = truncateText(
-    [
-      `mode=${mode}`,
-      ...resultLines,
-      ...artifactPath ? [`artifact=${artifactPath}`] : [],
-      ...results.length >= SUBAGENT_RESULT_LIMIT ? ["additional subagent results omitted"] : []
-    ].join("\n"),
-    SUBAGENT_OUTCOME_MAX_CHARS
-  );
-  return {
-    command: `subagent ${mode}`,
-    outcome,
-    observedAt
-  };
-}
-function normalizeDelegationResult(value) {
-  const record = isRecord(value) ? value : void 0;
-  if (!record) {
-    return [];
-  }
-  const agent = readOptionalTrimmedString(record.agent);
-  const status = readOptionalTrimmedString(record.status);
-  if (!agent || !status) {
-    return [];
-  }
-  const stdout = readOptionalTrimmedString(record.stdout);
-  const stderr = readOptionalTrimmedString(record.stderr);
-  const name = readOptionalTrimmedString(record.name);
-  const summary = firstMeaningfulLine(stdout ?? stderr);
-  return [
-    {
-      agent,
-      ...name ? { name } : {},
-      status,
-      ...summary ? { summary } : {}
-    }
-  ];
-}
-function isExpectedSubagentFindingSkip(code) {
-  return code === "feature_disabled" || code === "missing_active_set" || code === "missing_scope" || code === "misconfigured";
-}
-function firstMeaningfulLine(value) {
-  const line = value?.split(/\r?\n/u).map((part) => part.trim()).find((part) => part.length > 0);
-  return line ? truncateText(line, 500) : void 0;
-}
-function truncateText(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
-  return `${value.slice(0, Math.max(0, maxChars - 15)).trimEnd()} [truncated]`;
-}
-
-// src/adapters/shared/agenr-episode-summary-llm.ts
-function createAgenrEpisodeSummaryLlm(provider, modelId, apiKey) {
-  const client = createLlmClient(provider, modelId, { apiKey });
-  return {
-    complete: client.complete,
-    completeJson: client.completeJson,
-    metadata: {
-      modelRef: `${provider}/${modelId}`,
-      pricing: {
-        input: client.metadata.model.cost?.input ?? 0,
-        output: client.metadata.model.cost?.output ?? 0,
-        cacheRead: client.metadata.model.cost?.cacheRead ?? 0,
-        cacheWrite: client.metadata.model.cost?.cacheWrite ?? 0
-      },
-      usage: client.metadata.usage
-    }
-  };
-}
-
-// src/adapters/skeln/transcript/parser.ts
-import { createHash } from "crypto";
-import * as fs from "fs/promises";
-import path from "path";
-var SkelnTranscriptParser = class {
-  /**
-   * Parses one Skeln session JSONL file into normalized transcript messages.
-   *
-   * @param filePath - Absolute or relative Skeln session file.
-   * @returns Parsed transcript payload consumed by shared episode ingest.
-   */
-  async parseFile(filePath) {
-    const raw = await fs.readFile(filePath, "utf8");
-    const transcriptHash = createHash("sha256").update(raw).digest("hex");
-    const warnings = [];
-    const messages = [];
-    const records = parseJsonlRecords(raw, filePath, warnings);
-    const header = records[0] ? parseHeaderRecord(records[0], filePath, warnings) : {};
-    const sessionId = header.sessionId ?? deriveSkelnSessionIdFromFilePath(filePath);
-    const headerTimestamp = toIsoTimestamp(header.timestamp);
-    for (const record of records.slice(1)) {
-      if (record.type !== "message") {
-        continue;
-      }
-      const normalized = normalizeSkelnMessage(record.message);
-      if (!normalized) {
-        continue;
-      }
-      messages.push({
-        index: messages.length,
-        role: normalized.role,
-        text: normalized.text,
-        ...normalized.timestamp ? { timestamp: normalized.timestamp } : {}
-      });
-    }
-    const startedAt = messages[0]?.timestamp ?? headerTimestamp;
-    const endedAt = messages.at(-1)?.timestamp;
-    return {
-      messages,
-      metadata: {
-        ...sessionId ? { sessionId } : {},
-        ...header.cwd ? { workingDirectory: header.cwd, project: path.basename(header.cwd) } : {},
-        ...startedAt ? { startedAt } : {},
-        ...endedAt ? { endedAt } : {},
-        messageCount: messages.length,
-        transcriptHash,
-        reconstructedSurface: "skeln",
-        surfaceReconstructionSource: "reconstructed",
-        sourceIdentity: path.resolve(filePath),
-        sourceIdentityKind: "skeln_session_file"
-      },
-      warnings
-    };
-  }
-};
-var skelnTranscriptParser = new SkelnTranscriptParser();
-function parseJsonlRecords(raw, filePath, warnings) {
-  const records = [];
-  const lines = raw.split(/\r?\n/u);
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index]?.trim();
-    if (!line) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(line);
-      const record = isRecord(parsed) ? parsed : void 0;
-      if (!record) {
-        warnings.push(`Skipped non-object Skeln JSONL line ${index + 1} in ${filePath}.`);
-        continue;
-      }
-      records.push(record);
-    } catch (error) {
-      warnings.push(`Skipped malformed Skeln JSONL line ${index + 1} in ${filePath}: ${formatErrorMessage(error)}`);
-    }
-  }
-  if (records.length === 0) {
-    warnings.push(`Skipped empty Skeln transcript file: ${filePath}`);
-  }
-  return records;
-}
-function parseHeaderRecord(record, filePath, warnings) {
-  if (!record || record.type !== "session") {
-    warnings.push(`Skeln transcript ${filePath} is missing a session header.`);
-    return {};
-  }
-  return {
-    sessionId: readOptionalTrimmedString(record.id),
-    timestamp: readOptionalFiniteNumber(record.timestamp),
-    cwd: readOptionalTrimmedString(record.cwd)
-  };
-}
-function normalizeSkelnMessage(value) {
-  const message = isRecord(value) ? value : void 0;
-  if (!message) {
-    return void 0;
-  }
-  const role = normalizeRole(readOptionalTrimmedString(message.role));
-  if (!role) {
-    return void 0;
-  }
-  const text = normalizeMessageText(message.content);
-  if (!text) {
-    return void 0;
-  }
-  const timestamp = toIsoTimestamp(readOptionalFiniteNumber(message.timestamp));
-  return {
-    role,
-    text,
-    ...timestamp ? { timestamp } : {}
-  };
-}
-function normalizeRole(role) {
-  if (role === "user") {
-    return "user";
-  }
-  if (role === "assistant") {
-    return "assistant";
-  }
-  return void 0;
-}
-function normalizeMessageText(value) {
-  if (typeof value === "string") {
-    return value.trim();
-  }
-  if (!Array.isArray(value)) {
-    return "";
-  }
-  const parts = [];
-  for (const part of value) {
-    if (typeof part === "string") {
-      parts.push(part);
-      continue;
-    }
-    const record = isRecord(part) ? part : void 0;
-    const text = readOptionalTrimmedString(record?.text) ?? readOptionalTrimmedString(record?.content);
-    if (text) {
-      parts.push(text);
-    }
-  }
-  return parts.map((part) => part.trim()).filter(Boolean).join("\n").trim();
-}
-function toIsoTimestamp(timestamp) {
-  if (timestamp === void 0) {
-    return void 0;
-  }
-  const date = new Date(timestamp);
-  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-}
-function deriveSkelnSessionIdFromFilePath(filePath) {
-  const basename = path.basename(filePath).replace(/\.jsonl(?:\..*)?$/iu, "").trim();
-  return basename.length > 0 ? basename : void 0;
-}
-
-// src/adapters/skeln/episode/bounded-session-episode.ts
-function resolveSkelnSessionEpisodeTarget(context) {
-  return {
-    sessionId: String(context.sessionManager.getSessionId()),
-    sessionFile: resolveSessionFile(context)
-  };
-}
-async function writeSkelnBoundedSessionEpisode(params) {
-  const logger = params.logger ?? console;
-  const sessionFile = params.target.sessionFile;
-  const sessionId = params.target.sessionId;
-  const summaryDeadlineMs = Date.now() + EPISODE_SUMMARY_TIMEOUT_MS;
-  if (!sessionFile) {
-    logger.info(`[agenr] ${params.actionLabel} skipped for ${params.skipDetails} reason=no_session_file`);
-    return;
-  }
-  const episodeModel = resolveModel(params.services.agenrConfig, "episode");
-  const llmApiKey = resolveLlmApiKey(params.services.agenrConfig, episodeModel.provider);
-  const summaryLlm = createDeadlineAwareEpisodeSummaryLlm(
-    createAgenrEpisodeSummaryLlm(episodeModel.provider, episodeModel.modelId, llmApiKey),
-    summaryDeadlineMs
-  );
-  await writeBoundedSingleTranscriptEpisode({
-    filePath: sessionFile,
-    context: params.logContext,
-    actionLabel: params.actionLabel,
-    logger,
-    summaryDeadlineMs,
-    ports: {
-      files: createSingleTranscriptDiscoveryPort(sessionFile),
-      transcript: skelnTranscriptParser,
-      episodes: params.services.episodes,
-      createSummaryLlm: () => summaryLlm,
-      embedSummary: (summary) => embedEpisodeSummaryWithinBudget({
-        summary,
-        embedding: params.services.embedding,
-        embeddingAvailable: params.services.embeddingStatus.available,
-        deadlineMs: summaryDeadlineMs,
-        logger,
-        logContext: `[agenr] ${params.actionLabel} embedding skipped for ${params.logContext} file=${sessionFile}`
-      })
-    },
-    ingestOptions: {
-      source: "skeln",
-      genVersion: params.genVersion,
-      skipActiveSessionCheck: true,
-      activityThreshold: params.activityThreshold,
-      candidateOverrides: {
-        sessionId,
-        sourceRef: params.buildSourceRef(sessionFile),
-        agentId: null,
-        surface: "skeln",
-        metadataSource: "reconstructed"
-      }
-    }
-  });
-}
-function resolveSessionFile(context) {
-  try {
-    const sessionFile = context.sessionManager.getSessionFile().trim();
-    return sessionFile || void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/adapters/skeln/episode/episode-writer.ts
-var SKELN_EPISODE_GENERATOR_VERSION = "skeln-episodic-summary-v1";
-var SKELN_PHASE4_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD = {
-  minMaterialTurns: 8,
-  minDurationMs: 20 * 60 * 1e3
-};
-async function writeSkelnShutdownEpisode(params) {
-  await writeSkelnBoundedSessionEpisode({
-    target: params.target,
-    services: params.services,
-    logger: params.logger,
-    actionLabel: "skeln shutdown episode write",
-    genVersion: SKELN_EPISODE_GENERATOR_VERSION,
-    activityThreshold: SKELN_PHASE4_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD,
-    buildSourceRef: (sessionFile) => sessionFile,
-    logContext: `session=${params.target.sessionId} key=skeln:${params.target.sessionId}`,
-    skipDetails: `session=${params.target.sessionId}`
-  });
-}
-
-// src/adapters/skeln/episode/shutdown-episode-write.ts
-function buildSkelnSessionShutdownEpisodeWork(params) {
-  const target = resolveSkelnSessionEpisodeTarget(params.context);
-  const shutdownWork = params.event.reason === "quit" ? writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger).finally(() => closeSkelnServicesAfterShutdown(params.servicesPromise)) : writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger);
-  return shutdownWork.catch((error) => {
-    logSkelnShutdownEpisodeFailure(error, params.logger);
-  });
-}
-function scheduleSkelnSessionShutdownEpisodeWrite(params) {
-  const work = buildSkelnSessionShutdownEpisodeWork(params);
-  if (params.event.reason === "quit" && params.event.deferWork) {
-    params.event.deferWork(work);
-    return Promise.resolve();
-  }
-  if (params.event.reason === "quit") {
-    return work;
-  }
-  void work;
-  return Promise.resolve();
-}
-function logSkelnShutdownEpisodeFailure(error, logger) {
-  const log = logger ?? console;
-  log.warn(`[agenr] skeln shutdown episode failed: ${formatErrorMessage(error)}`);
-}
-async function closeSkelnServicesAfterShutdown(servicesPromise) {
-  try {
-    const services = await servicesPromise;
-    await services.close();
-  } catch {
-  }
-}
-async function writeScopedSkelnShutdownEpisode(servicesPromise, target, logger) {
-  const services = await servicesPromise;
-  if (!services.capabilities.shutdownEpisodes) {
-    return;
-  }
-  await writeSkelnShutdownEpisode({ target, services, logger });
-}
-
-// src/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/app/features/capabilities.ts
-function resolveRuntimeCapabilities(featureFlags, input = {}) {
-  const sessionMemoryFlagEnabled = featureFlags.sessionTreeLineage || featureFlags.sessionTreeCompaction;
-  const sessionMemory = resolveRepositoryBackedCapability(sessionMemoryFlagEnabled, input.sessionMemoryRepository);
-  return {
-    workingMemory: resolveRepositoryBackedCapability(featureFlags.workingMemory, input.workingMemoryRepository),
-    sessionMemory,
-    shutdownEpisodes: sessionMemory === "enabled",
-    goalContinuation: resolveGoalContinuationCapability(featureFlags.goalContinuation, input.goalContinuationHostPort)
-  };
-}
-function resolveRepositoryBackedCapability(featureEnabled, repository) {
-  if (!featureEnabled) {
-    return "disabled";
-  }
-  return repository ? "enabled" : "misconfigured";
-}
-function resolveGoalContinuationCapability(featureEnabled, hostPort) {
-  if (!featureEnabled) {
-    return "disabled";
-  }
-  return hostPort ? "enabled" : "misconfigured";
-}
-
-// src/app/features/runtime-policy.ts
-function resolveRuntimePolicy(featureFlags, input = {}) {
-  return {
-    featureFlags,
-    capabilities: resolveRuntimeCapabilities(featureFlags, {
-      workingMemoryRepository: input.workingMemoryRepository,
-      sessionMemoryRepository: input.sessionMemoryRepository,
-      goalContinuationHostPort: input.goalContinuationHostPort
-    }),
-    ...input.memoryPolicy ? { memoryPolicy: input.memoryPolicy } : {}
-  };
-}
-
-// 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 as createHash2 } from "crypto";
-
-// src/app/working-memory/lifecycle-checkpoint.ts
-async function attachWorkingCheckpointRefresh(event, result, workingMemory) {
-  const refreshRequest = resolveWorkingCheckpointRefreshRequest(event, result);
-  if (!refreshRequest) {
-    return result;
-  }
-  const workingCheckpointRefresh = workingMemory ? await mergeWorkingCheckpoint(refreshRequest, workingMemory) : skippedRefreshWithoutWorkingMemory(refreshRequest.attachLabel);
-  return {
-    ...result,
-    workingCheckpointRefresh
-  };
-}
-async function mergeWorkingCheckpoint(request, workingMemory) {
-  const scope = resolveWorkingRefreshScope(request.event);
-  if (!scope) {
-    return {
-      ok: false,
-      reason: "missing_scope",
-      message: `${request.lifecycleLabel} requires working-scope facts.`
-    };
-  }
-  const result = await workingMemory.run({
-    action: "update",
-    scope,
-    operation: {
-      type: "merge_checkpoint",
-      checkpoint: {
-        summary: request.summary,
-        recordedAt: request.event.observedAt
-      }
-    },
-    updateReason: request.updateReason,
-    actor: "runtime",
-    source: "lifecycle_hook"
-  });
-  if (!result.ok) {
-    return mapWorkingMemoryRefreshFailure(result.code, result.message, request.lifecycleLabel);
-  }
-  if (result.action !== "update") {
-    return {
-      ok: false,
-      reason: "working_memory_unavailable",
-      message: `Expected working-memory update result, received ${result.action}.`
-    };
-  }
-  return {
-    ok: true,
-    action: "working_checkpoint_refreshed",
-    workingSetId: result.workingSet.id,
-    revision: result.workingSet.revision
-  };
-}
-function resolveWorkingCheckpointRefreshRequest(event, result) {
-  const compactionEvent = resolveCompactionCheckpointRefreshEvent(event, result);
-  if (compactionEvent) {
-    const summary = normalizeOptionalString(compactionEvent.artifact.summary);
-    if (!summary) {
-      return void 0;
-    }
-    const sourceId = normalizeOptionalString(compactionEvent.artifact.sourceId) ?? "unknown";
-    return {
-      event: compactionEvent,
-      summary,
-      updateReason: `Refreshed working checkpoint from session compaction ${sourceId}.`,
-      lifecycleLabel: "compaction checkpoint refresh",
-      attachLabel: "Compaction checkpoint refresh"
-    };
-  }
-  const shutdownEvent = resolveShutdownCheckpointRefreshEvent(event, result);
-  if (!shutdownEvent) {
-    return void 0;
-  }
-  const reason = normalizeShutdownReason(shutdownEvent.shutdownReason);
-  return {
-    event: shutdownEvent,
-    summary: `Session shutdown (${reason}) recorded. Resume from the latest working-set snapshot; no implicit close was performed.`,
-    updateReason: `Recorded working checkpoint from session shutdown (${reason}).`,
-    lifecycleLabel: "shutdown checkpoint refresh",
-    attachLabel: "Shutdown checkpoint refresh"
-  };
-}
-function resolveCompactionCheckpointRefreshEvent(event, result) {
-  if (event.type !== "session_compact" || result.artifact?.kind !== "compaction_checkpoint") {
-    return void 0;
-  }
-  const artifact = event.artifact;
-  if (!isCompactionCheckpointArtifact(artifact)) {
-    return void 0;
-  }
-  return {
-    ...event,
-    type: "session_compact",
-    artifact
-  };
-}
-function resolveShutdownCheckpointRefreshEvent(event, result) {
-  if (event.type !== "session_shutdown" || result.accepted !== true) {
-    return void 0;
-  }
-  return {
-    ...event,
-    type: "session_shutdown"
-  };
-}
-function isCompactionCheckpointArtifact(artifact) {
-  return artifact?.kind === "compaction_checkpoint";
-}
-function resolveWorkingRefreshScope(event) {
-  if (event.workingScope && Object.keys(event.workingScope).length > 0) {
-    return event.workingScope;
-  }
-  return void 0;
-}
-function mapWorkingMemoryRefreshFailure(code, message, lifecycleLabel) {
-  if (code === "feature_disabled") {
-    return {
-      ok: false,
-      reason: "not_applicable",
-      message: `Working memory is disabled; ${lifecycleLabel} was skipped.`
-    };
-  }
-  if (code === "missing_active_set") {
-    return {
-      ok: false,
-      reason: "no_active_working_set",
-      code,
-      message
-    };
-  }
-  return {
-    ok: false,
-    reason: "working_memory_unavailable",
-    code,
-    message
-  };
-}
-function normalizeShutdownReason(shutdownReason) {
-  const trimmed = shutdownReason?.trim();
-  return trimmed && trimmed.length > 0 ? trimmed : "unknown";
-}
-function skippedRefreshWithoutWorkingMemory(label) {
-  return {
-    ok: false,
-    reason: "not_applicable",
-    message: `${label} requires a working-memory service, but none was wired into the runtime.`
-  };
-}
-
-// src/app/session-memory/trigger-router.ts
-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 attachWorkingCheckpointRefresh(
-      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.workingMemory
-    );
-  }
-  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 attachWorkingCheckpointRefresh(
-    event,
-    {
-      accepted: true,
-      action,
-      message: buildAcceptedMessage(event.type, action, artifact, lineageEdge),
-      ...lineageEdge ? { lineageEdge } : {},
-      ...artifact ? { artifact } : {}
-    },
-    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 createHash2("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.`;
+  return resolveBeforeTurnInjection(event, scope, event.systemPrompt, systemPromptWithDoctrine, context, deps);
 }
-function invalidEvent(message) {
+function buildAgenrSkelnInjectionMessage(content) {
   return {
-    accepted: false,
-    reason: "invalid_event",
-    message
+    role: "user",
+    content: [{ type: "text", text: content }],
+    timestamp: Date.now()
   };
 }
-function isCheckpointRelevantTrigger(type) {
-  return type === "session_before_fork" || type === "session_before_compact" || type === "session_before_tree" || type === "session_shutdown";
-}
-
-// src/app/working-memory/close-service.ts
-function resolveCloseTerminalStatus(closeMode) {
-  return closeMode === "abandon" ? "abandoned" : "closed";
-}
-function buildWorkingCloseSnapshot(input) {
-  const finalCheckpoint = buildFinalCheckpoint(input);
-  const candidates = [...input.snapshot.candidates ?? []];
-  if (input.createEpisode && !candidates.some((candidate) => candidate.kind === "episodic")) {
-    candidates.push({
-      kind: "episodic",
-      summary: finalCheckpoint.summary,
-      provenance: {
-        evidenceEventSequences: input.eventSequences,
-        sourceRef: `working_set:${input.workingSetId}#rev:${input.currentRevision}`,
-        note: input.closeReason
-      },
-      promotionStatus: "pending"
-    });
+function appendPromptSection(systemPrompt, section) {
+  const trimmedSection = section.trim();
+  if (trimmedSection.length === 0 || systemPrompt.includes(trimmedSection)) {
+    return systemPrompt;
   }
-  return {
-    snapshot: {
-      ...input.snapshot,
-      checkpoint: finalCheckpoint,
-      candidates: candidates.length > 0 ? candidates : void 0,
-      lastMaterialChange: input.closeReason
-    },
-    candidates
-  };
-}
-function buildFinalCheckpoint(input) {
-  const summary = normalizeSummary(input.closeReason) ?? input.snapshot.summary ?? input.snapshot.objective ?? "Working set closed.";
-  return {
-    summary,
-    recordedAt: input.now,
-    ...input.snapshot.nextActions && input.snapshot.nextActions.length > 0 ? { nextActions: input.snapshot.nextActions.map((action) => action.text).filter((text) => text.trim().length > 0) } : {},
-    ...input.snapshot.blockers && input.snapshot.blockers.length > 0 ? { blockers: input.snapshot.blockers } : {}
-  };
-}
-function normalizeSummary(value) {
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-
-// src/app/working-memory/repository.ts
-function isWorkingSetCreateFailure(result) {
-  return "kind" in result;
-}
-function isWorkingSetWriteFailure(result) {
-  return "kind" in result;
-}
+  return `${systemPrompt.trimEnd()}
 
-// src/app/working-memory/results.ts
-function createFailure(code, message, details) {
-  return {
-    ok: false,
-    code,
-    message,
-    ...details ? { details } : {}
-  };
+${trimmedSection}`;
 }
-function writeFailureToResult(workingSetId, failure) {
-  switch (failure.kind) {
-    case "not_found":
-      return createFailure("not_found", "Working set was not found.", workingSetId ? { workingSetId } : void 0);
-    case "revision_conflict":
-      return createFailure("revision_conflict", "Working-set revision conflict.", {
-        actualRevision: failure.actualRevision,
-        ...workingSetId ? { workingSetId } : {}
-      });
-    case "terminal_status":
-      return createFailure("terminal_status", `Working set is already ${failure.status}.`, {
-        status: failure.status,
-        ...workingSetId ? { workingSetId } : {}
+async function resolveSessionStartInjection(scope, baseSystemPrompt, systemPrompt, servicesPromise) {
+  let workingInjection;
+  try {
+    const services = await servicesPromise;
+    workingInjection = await resolveWorkingContextInjection(services, scope, `skeln:session-start:${scope.sessionKey}`);
+    if (services.skelnConfig.memoryPolicy?.sessionStart?.enabled === false) {
+      return composeSkelnBeforeAgentStartResult({
+        baseSystemPrompt,
+        systemPrompt,
+        recallKind: "session_start_recall",
+        recallSkippedReason: "memoryPolicy.sessionStart.enabled=false",
+        workingInjection
       });
-  }
-}
-
-// src/app/working-memory/scope-resolver.ts
-function resolveWorkingScope(input) {
-  const scope = normalizeWorkingScope(input);
-  if (scope.taskId) {
-    return {
-      ok: true,
-      scope: {
-        ...scope,
-        scopeKind: "task",
-        scopeKey: `task:${scope.taskId}`
-      }
-    };
-  }
-  if (scope.conversationKey) {
-    return {
-      ok: true,
-      scope: {
-        ...scope,
-        scopeKind: "conversation",
-        scopeKey: `conversation:${scope.conversationKey}`
-      }
-    };
-  }
-  if (scope.gitRoot && scope.gitBranch) {
-    return {
-      ok: true,
-      scope: {
-        ...scope,
-        scopeKind: "git_branch",
-        scopeKey: buildScopeKey("git_branch", [scope.project, scope.gitRoot, scope.gitBranch])
-      }
-    };
-  }
-  if (scope.gitRoot && scope.cwd) {
-    return {
-      ok: true,
-      scope: {
-        ...scope,
-        scopeKind: "git_cwd",
-        scopeKey: buildScopeKey("git_cwd", [scope.project, scope.gitRoot, scope.cwd])
-      }
-    };
-  }
-  return {
-    ok: false,
-    code: "missing_scope",
-    message: "Working memory needs a task, conversation, or git scope."
-  };
-}
-function normalizeWorkingScope(input) {
-  const scope = input ?? {};
-  return {
-    ...normalizeField("sessionId", scope.sessionId),
-    ...normalizeField("gitRoot", scope.gitRoot),
-    ...normalizeField("gitBranch", scope.gitBranch),
-    ...normalizeField("cwd", scope.cwd),
-    ...normalizeField("project", scope.project),
-    ...normalizeField("taskId", scope.taskId),
-    ...normalizeField("conversationKey", scope.conversationKey)
-  };
-}
-function buildScopeKey(prefix, parts) {
-  return [prefix, ...parts.filter((part) => part !== void 0)].join(":");
-}
-function normalizeField(key, value) {
-  if (typeof value !== "string") {
-    return {};
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? { [key]: trimmed } : {};
-}
-
-// src/app/working-memory/find-current-set.ts
-async function lookupCurrentWorkingSets(scope, repository) {
-  const scopeResolution = resolveWorkingScope(scope);
-  if (!scopeResolution.ok) {
-    return createFailure("missing_scope", scopeResolution.message);
-  }
-  const matches = await repository.findCurrentWorkingSets(scopeResolution.scope);
-  if (matches.length > 1) {
-    return createFailure("ambiguous_scope", "Multiple current working sets matched the resolved scope.", {
-      scopeKey: scopeResolution.scope.scopeKey,
-      workingSetIds: matches.map((match) => match.id)
+    }
+    const sessionStartPatch = await runSessionStart(
+      {
+        sessionKey: scope.sessionKey,
+        policy: resolveSessionStartPolicy(services.skelnConfig.memoryPolicy)
+      },
+      services.sessionStart
+    );
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "session_start_recall",
+      recallText: formatAgenrSessionStartRecall(sessionStartPatch),
+      workingInjection
     });
-  }
-  return {
-    ok: true,
-    scope: scopeResolution.scope,
-    matches
-  };
-}
-async function findUniqueCurrentWorkingSet(scope, repository) {
-  const lookup = await lookupCurrentWorkingSets(scope, repository);
-  if (!lookup.ok) {
-    return lookup;
-  }
-  if (lookup.matches.length === 0) {
-    return createFailure("missing_active_set", "No current working set matched the resolved scope.", {
-      scopeKey: lookup.scope.scopeKey
+  } catch (error) {
+    logInjectionFailure("session-start", scope, error);
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "session_start_recall",
+      recallFailureReason: error instanceof Error ? error.message : String(error),
+      workingInjection
     });
   }
-  return {
-    ok: true,
-    workingSet: lookup.matches[0],
-    scope: lookup.scope
-  };
-}
-
-// src/app/working-memory/select-working-set.ts
-async function selectWorkingSet(params, repository) {
-  const workingSetId = params.workingSetId?.trim();
-  if (workingSetId) {
-    const workingSet = await repository.getWorkingSet(workingSetId);
-    if (!workingSet) {
-      return createFailure("not_found", `Working set ${workingSetId} was not found.`, { workingSetId });
-    }
-    return { ok: true, workingSet };
-  }
-  const current = await findUniqueCurrentWorkingSet(params.scope, repository);
-  if (!current.ok) {
-    return current;
-  }
-  return {
-    ok: true,
-    workingSet: current.workingSet,
-    scope: current.scope
-  };
-}
-
-// src/app/working-memory/validation.ts
-function normalizeRequiredString(value, message) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
-    return createFailure("invalid_request", message);
-  }
-  return { ok: true, value: trimmed };
-}
-function normalizeExpectedRevision(value) {
-  if (value === void 0 || !Number.isInteger(value) || value < 0) {
-    return createFailure("invalid_request", "expectedRevision must be a non-negative integer.");
-  }
-  return { ok: true, value };
-}
-function canDefaultExpectedRevision(source) {
-  return isTrustedHostMutationSource(source);
-}
-function resolveExpectedRevision(selectedRevision, providedRevision, source) {
-  if (providedRevision === void 0) {
-    if (!canDefaultExpectedRevision(source)) {
-      return createFailure("invalid_request", "expectedRevision must be a non-negative integer.");
-    }
-    return { ok: true, value: selectedRevision };
-  }
-  return normalizeExpectedRevision(providedRevision);
-}
-function validateWorkingBudgetState(budget) {
-  const entries = [
-    ["tokenBudget", budget.tokenBudget],
-    ["tokenUsed", budget.tokenUsed],
-    ["wallClockBudgetSeconds", budget.wallClockBudgetSeconds],
-    ["wallClockUsedSeconds", budget.wallClockUsedSeconds],
-    ["turnBudget", budget.turnBudget],
-    ["turnsUsed", budget.turnsUsed],
-    ["requireReviewAfterSeconds", budget.requireReviewAfterSeconds]
-  ];
-  for (const [key, value] of entries) {
-    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
-      return createFailure("invalid_request", `${key} must be a non-negative finite number.`);
-    }
-  }
-  return { ok: true };
 }
-function validateWorkingUsageDelta(usage) {
-  const entries = [
-    ["tokenDelta", usage.tokenDelta],
-    ["wallClockSecondsDelta", usage.wallClockSecondsDelta],
-    ["turnDelta", usage.turnDelta]
-  ];
-  const hasDelta = entries.some(([, value]) => value !== void 0);
-  if (!hasDelta) {
-    return createFailure("invalid_request", "account_usage requires at least one usage delta.");
+async function resolveBeforeTurnInjection(event, scope, baseSystemPrompt, systemPrompt, context, deps) {
+  const services = await deps.servicesPromise;
+  const compactionContext = await resolveSkelnCompactionPromptContext(scope, services, deps.compactionPromptTracker);
+  const workingInjection = await resolveWorkingContextInjection(services, scope, `skeln:before-turn:${scope.sessionKey}`);
+  if (services.skelnConfig.memoryPolicy?.beforeTurn?.enabled === false) {
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "before_turn_recall",
+      recallSkippedReason: "memoryPolicy.beforeTurn.enabled=false",
+      recallText: compactionContext,
+      workingInjection
+    });
   }
-  for (const [key, value] of entries) {
-    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
-      return createFailure("invalid_request", `${key} must be a non-negative finite number.`);
-    }
+  const currentTurnText = normalizePromptText(event.prompt);
+  if (!currentTurnText) {
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "before_turn_recall",
+      recallSkippedReason: "empty turn prompt",
+      recallText: compactionContext,
+      workingInjection
+    });
   }
-  return { ok: true };
-}
-
-// src/app/working-memory/handlers/close.ts
-async function handleClose(params, repository, timestamp) {
-  if (!isTrustedHostMutationSource(params.source)) {
-    return createFailure(
-      "close_not_allowed",
-      "agenr_work close is reserved for /goal clear. Record progress with merge_checkpoint and leave the working set open."
+  try {
+    const branchMessages = extractSkelnBeforeTurnBranchMessages(context.sessionManager.getBranch());
+    const beforeTurnPatch = await runBeforeTurn(
+      {
+        sessionKey: scope.sessionKey,
+        currentTurnText,
+        recentTurns: extractRecentTurnsFromMessages(branchMessages),
+        policy: resolveBeforeTurnPolicy(services.skelnConfig.memoryPolicy)
+      },
+      services.beforeTurn
     );
-  }
-  const closeReason = normalizeRequiredString(params.closeReason, "agenr_work close requires closeReason.");
-  if (!closeReason.ok) {
-    return closeReason;
-  }
-  const selection = await selectWorkingSet(params, repository);
-  if (!selection.ok) {
-    return selection;
-  }
-  const expectedRevision = resolveExpectedRevision(selection.workingSet.revision, params.expectedRevision, params.source);
-  if (!expectedRevision.ok) {
-    return expectedRevision;
-  }
-  if (isCloseManagedStatus(selection.workingSet.status)) {
-    return createFailure("terminal_status", `Working set ${selection.workingSet.id} is already ${selection.workingSet.status}.`, {
-      workingSetId: selection.workingSet.id,
-      status: selection.workingSet.status
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "before_turn_recall",
+      recallText: mergeInjectionContent(compactionContext, formatAgenrBeforeTurnRecall(beforeTurnPatch)),
+      workingInjection
+    });
+  } catch (error) {
+    logInjectionFailure("before-turn", scope, error);
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "before_turn_recall",
+      recallFailureReason: error instanceof Error ? error.message : String(error),
+      recallText: compactionContext,
+      workingInjection
     });
   }
-  const events = await repository.listWorkingEvents(selection.workingSet.id, CLOSE_EVENT_HISTORY_LIMIT);
-  const terminalStatus = resolveCloseTerminalStatus(params.closeMode);
-  const closePayload = buildWorkingCloseSnapshot({
-    workingSetId: selection.workingSet.id,
-    snapshot: selection.workingSet.snapshot,
-    currentRevision: selection.workingSet.revision,
-    closeReason: closeReason.value,
-    createEpisode: params.createEpisode,
-    eventSequences: events.map((event) => event.sequence),
-    now: timestamp
-  });
-  const writeResult = await repository.updateWorkingSet({
-    workingSetId: selection.workingSet.id,
-    expectedRevision: expectedRevision.value,
-    eventType: terminalStatus,
-    payload: {
-      closeReason: closeReason.value,
-      closeMode: params.closeMode ?? "close",
-      candidates: closePayload.candidates,
-      sourceRef: `working_set:${selection.workingSet.id}#rev:${selection.workingSet.revision}`
-    },
-    status: terminalStatus,
-    snapshot: closePayload.snapshot,
-    title: selection.workingSet.title,
-    objective: selection.workingSet.snapshot.objective,
-    closedAt: timestamp,
-    closeReason: closeReason.value,
-    actor: params.actor,
-    source: params.source,
-    now: timestamp
-  });
-  return toCloseResult(selection.workingSet.id, writeResult, closePayload.candidates);
 }
-function toCloseResult(workingSetId, writeResult, candidates) {
-  if (isWorkingSetWriteFailure(writeResult)) {
-    return writeFailureToResult(workingSetId, writeResult);
-  }
+function composeSkelnBeforeAgentStartResult(input) {
+  const recallText = input.recallText?.trim();
+  const memoryTrace = buildBeforeAgentStartMemoryTrace({
+    baseSystemPrompt: input.baseSystemPrompt,
+    systemPrompt: input.systemPrompt,
+    recallKind: input.recallKind,
+    recallText,
+    recallSkippedReason: input.recallSkippedReason,
+    recallFailureReason: input.recallFailureReason,
+    workingContextTrace: input.workingInjection?.trace
+  });
   return {
-    ok: true,
-    action: "close",
-    workingSet: writeResult.workingSet,
-    event: writeResult.event,
-    candidates
+    systemPrompt: input.systemPrompt,
+    ...recallText ? { message: buildAgenrSkelnInjectionMessage(recallText) } : {},
+    ...input.workingInjection?.transientMessages ? { transientMessages: input.workingInjection.transientMessages } : {},
+    ...input.workingInjection?.workingContextAudit ? { workingContextAudit: input.workingInjection.workingContextAudit } : {},
+    ...memoryTrace.length > 0 ? { memoryTrace } : {}
   };
 }
-
-// src/app/working-memory/goal-generation.ts
-var INITIAL_GOAL_GENERATION = 1;
-function readGoalGeneration(snapshot) {
-  return snapshot?.goalGeneration ?? INITIAL_GOAL_GENERATION;
-}
-function nextGoalGenerationAfterObjectiveChange(snapshot, nextObjective) {
-  if (snapshot.objective === nextObjective) {
-    return readGoalGeneration(snapshot);
+async function resolveWorkingContextInjection(services, scope, sourceRef) {
+  const gate = resolveWorkingContextGate(services.capabilities.workingMemory, services.skelnConfig.memoryPolicy);
+  if (!gate.ok) {
+    return { trace: traceMemorySkipped("working_context", gate.reason) };
   }
-  return readGoalGeneration(snapshot) + 1;
+  return loadWorkingContextProjection(services, scope, sourceRef);
 }
-
-// src/app/working-memory/resolve-create-scope.ts
-async function resolveCreateScope(params, repository) {
-  const workingSetId = params.workingSetId?.trim();
-  if (workingSetId) {
-    const workingSet = await repository.getWorkingSet(workingSetId);
-    if (workingSet) {
-      return createFailure("active_set_exists", "A working set is already active for this scope.", {
-        workingSetId: workingSet.id,
-        scopeKey: workingSet.scopeKey
-      });
-    }
-    return createFailure("not_found", `Working set ${workingSetId} was not found.`, { workingSetId });
-  }
-  const lookup = await lookupCurrentWorkingSets(params.scope, repository);
-  if (!lookup.ok) {
-    return lookup;
-  }
-  if (lookup.matches.length === 1) {
-    const existing = lookup.matches[0];
-    return createFailure("active_set_exists", "A working set already exists for this scope.", {
-      workingSetId: existing.id,
-      scopeKey: lookup.scope.scopeKey
+async function loadWorkingContextProjection(services, scope, sourceRef) {
+  try {
+    const projection = await services.workingMemory.renderProjection({
+      sourceRef,
+      scope: toWorkingScopeFromSkelnSession(scope)
     });
+    if (!shouldInjectWorkingContext(projection)) {
+      const reason = projection.renderMode !== "full" ? "working projection stub" : "empty working projection";
+      return { trace: traceMemorySkipped("working_context", reason) };
+    }
+    const workingContextAudit = toWorkingContextAuditPointer(projection);
+    return {
+      transientMessages: [buildAgenrSkelnInjectionMessage(projection.content)],
+      ...workingContextAudit ? { workingContextAudit } : {},
+      trace: traceWorkingContextInjected(workingContextAudit, projection.content)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[agenr] working-context projection failed for session=${scope.sessionId} key=${scope.sessionKey}: ${message}`);
+    return { trace: traceMemoryFailed("working_context", message) };
   }
-  return {
-    ok: true,
-    scope: lookup.scope
-  };
+}
+function logInjectionFailure(phase, scope, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[agenr] ${phase} recall failed for session=${scope.sessionId} key=${scope.sessionKey}: ${message}`);
 }
 
-// src/app/working-memory/handlers/create.ts
-async function handleCreate(params, repository, timestamp, sourceLabel) {
-  const operation = params.operation;
-  if (!operation || operation.type !== "set_objective") {
-    return createFailure("invalid_request", "agenr_work create requires a set_objective operation.");
-  }
-  const updateReason = normalizeRequiredString(params.updateReason, "agenr_work create requires updateReason.");
-  if (!updateReason.ok) {
-    return updateReason;
-  }
-  const scopeResolution = await resolveCreateScope(params, repository);
-  if (!scopeResolution.ok) {
-    return scopeResolution;
-  }
-  const { scope } = scopeResolution;
-  const initialBudget = params.initialBudget ? validateWorkingBudgetState(params.initialBudget) : { ok: true };
-  if (!initialBudget.ok) {
-    return initialBudget;
-  }
-  const created = await repository.createWorkingSet({
-    scope,
-    title: operation.title,
-    objective: operation.objective,
-    status: "active",
-    snapshot: {
-      goalGeneration: INITIAL_GOAL_GENERATION,
-      objective: operation.objective,
-      continuation: { policy: params.continuationPolicy ?? "manual" },
-      ...params.initialBudget ? { budgets: params.initialBudget } : {},
-      lastMaterialChange: updateReason.value
-    },
-    actor: params.actor,
-    source: params.source,
-    sourceLabel,
-    sessionId: scope.sessionId,
-    now: timestamp
-  });
-  if (isWorkingSetCreateFailure(created)) {
-    return createFailure("active_set_exists", "A working set already exists for this scope.", {
-      scopeKey: created.scopeKey
+// src/adapters/skeln/hooks/subagent-findings.ts
+var SUBAGENT_OUTCOME_MAX_CHARS = 3e3;
+var SUBAGENT_RESULT_LIMIT = 6;
+async function recordSkelnSubagentFindings(servicesPromise, resolveScope, context, event) {
+  const commandNote = buildSkelnSubagentCommandNote(event, (/* @__PURE__ */ new Date()).toISOString());
+  if (!commandNote) {
+    return;
+  }
+  try {
+    const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+    const result = await services.workingMemory.run({
+      action: "update",
+      scope: toWorkingScopeFromSkelnSession(scope),
+      operation: {
+        type: "add_command_note",
+        command: commandNote
+      },
+      updateReason: "Recorded bounded subagent findings on the parent working set.",
+      actor: "runtime",
+      source: "lifecycle_hook"
     });
-  }
-  return {
-    ok: true,
-    action: "create",
-    workingSet: created.workingSet,
-    event: created.event,
-    projection: createToolSuccessProjection(created.workingSet, "create", timestamp)
-  };
-}
-
-// src/app/working-memory/handlers/get.ts
-async function handleGet(params, repository, timestamp) {
-  const selection = await selectWorkingSet(params, repository);
-  if (!selection.ok) {
-    return selection;
-  }
-  const events = params.includeEvents ? await repository.listWorkingEvents(selection.workingSet.id, normalizeEventLimit(params.eventLimit)) : void 0;
-  return {
-    ok: true,
-    action: "get",
-    workingSet: selection.workingSet,
-    ...events ? { events } : {},
-    projection: createToolSuccessProjection(selection.workingSet, "get", timestamp)
-  };
-}
-
-// src/app/working-memory/handlers/list.ts
-async function handleList(params, repository) {
-  const scopeResolution = params.scope ? resolveWorkingScope(params.scope) : void 0;
-  if (scopeResolution && !scopeResolution.ok) {
-    return createFailure("missing_scope", scopeResolution.message);
-  }
-  const workingSets = await repository.listWorkingSets({
-    ...scopeResolution?.ok ? { scope: scopeResolution.scope } : {},
-    limit: normalizeListLimit(params.listLimit)
-  });
-  return {
-    ok: true,
-    action: "list",
-    workingSets
-  };
-}
-
-// src/app/working-memory/apply-operation.ts
-function applyOperation(record, operation, updateReason) {
-  const snapshot = { ...record.snapshot, lastMaterialChange: updateReason };
-  let status = record.status;
-  let title = record.title;
-  let objective = record.snapshot.objective;
-  switch (operation.type) {
-    case "set_objective":
-      snapshot.goalGeneration = nextGoalGenerationAfterObjectiveChange(snapshot, operation.objective);
-      snapshot.objective = operation.objective;
-      objective = operation.objective;
-      title = operation.title ?? title;
-      break;
-    case "replace_plan":
-      snapshot.currentPlan = operation.currentPlan;
-      snapshot.nextActions = operation.nextActions;
-      break;
-    case "merge_checkpoint":
-      snapshot.checkpoint = operation.checkpoint;
-      if (operation.checkpoint.nextActions) {
-        snapshot.nextActions = operation.checkpoint.nextActions.map((text) => ({ text, status: "pending" }));
-      }
-      if (operation.checkpoint.blockers) {
-        snapshot.blockers = operation.checkpoint.blockers;
-      }
-      break;
-    case "add_file_note":
-      snapshot.files = [...snapshot.files ?? [], operation.file];
-      break;
-    case "add_command_note":
-      snapshot.commands = [...snapshot.commands ?? [], operation.command];
-      break;
-    case "record_decision":
-      snapshot.decisions = [...snapshot.decisions ?? [], operation.decision];
-      break;
-    case "record_assumption":
-      snapshot.assumptions = [...snapshot.assumptions ?? [], operation.assumption];
-      break;
-    case "set_next_actions":
-      snapshot.nextActions = operation.nextActions;
-      break;
-    case "set_status":
-      if (isCloseManagedStatus(operation.status)) {
-        return createFailure("invalid_request", "Use agenr_work close for closed or abandoned terminal states.");
-      }
-      status = operation.status;
-      break;
-    case "add_candidate":
-      snapshot.candidates = [...snapshot.candidates ?? [], operation.candidate];
-      break;
-    case "configure_budget": {
-      const budget = mergeBudgetState(snapshot.budgets, operation.budget);
-      if (!budget.ok) {
-        return budget;
-      }
-      const limited = applyBudgetLimitedStatus(status, budget.value, updateReason);
-      snapshot.budgets = limited.budgets;
-      status = limited.status;
-      break;
-    }
-    case "account_usage": {
-      const budget = applyUsageDelta(snapshot.budgets, operation.usage, updateReason);
-      if (!budget.ok) {
-        return budget;
-      }
-      const limited = applyBudgetLimitedStatus(status, budget.value, operation.usage.recordedAt ?? updateReason);
-      snapshot.budgets = limited.budgets;
-      status = limited.status;
-      break;
+    if (!result.ok && !isExpectedSubagentFindingSkip(result.code)) {
+      console.warn(`[agenr] subagent findings working-memory update failed: ${result.message}`);
     }
-    case "set_continuation_policy":
-      snapshot.continuation = pruneContinuation({
-        ...snapshot.continuation,
-        policy: operation.policy,
-        ...operation.resumeAfter !== void 0 ? { resumeAfter: operation.resumeAfter } : {},
-        ...operation.staleAfter !== void 0 ? { staleAfter: operation.staleAfter } : {},
-        ...operation.stopReason !== void 0 ? { stopReason: operation.stopReason } : {}
-      });
-      break;
+  } catch (error) {
+    console.warn(`[agenr] subagent findings capture failed: ${formatErrorMessage(error)}`);
   }
-  return {
-    ok: true,
-    snapshot,
-    status,
-    title,
-    objective
-  };
 }
-function mergeBudgetState(current, update) {
-  const validation = validateWorkingBudgetState(update);
-  if (!validation.ok) {
-    return validation;
+function buildSkelnSubagentCommandNote(event, observedAt) {
+  if (event.toolName !== "subagent" || event.isError) {
+    return void 0;
   }
-  return {
-    ok: true,
-    value: pruneBudget({
-      ...current ?? {},
-      ...update
-    })
-  };
-}
-function applyUsageDelta(current, usage, limitedAt) {
-  const validation = validateWorkingUsageDelta(usage);
-  if (!validation.ok) {
-    return validation;
+  const details = isRecord(event.details) ? event.details : void 0;
+  if (!details) {
+    return void 0;
   }
-  const next = {
-    ...current ?? {},
-    tokenUsed: addDelta(current?.tokenUsed, usage.tokenDelta),
-    wallClockUsedSeconds: addDelta(current?.wallClockUsedSeconds, usage.wallClockSecondsDelta),
-    turnsUsed: addDelta(current?.turnsUsed, usage.turnDelta)
-  };
-  const limitReason = resolveBudgetLimitReason(next);
-  return {
-    ok: true,
-    value: pruneBudget({
-      ...next,
-      ...limitReason ? { limitReason, limitedAt: usage.recordedAt ?? limitedAt } : {}
-    })
-  };
-}
-function applyBudgetLimitedStatus(currentStatus, budget, limitedAt) {
-  const limitReason = resolveBudgetLimitReason(budget);
-  if (!limitReason || !budget) {
-    return { status: currentStatus, budgets: budget };
+  const mode = readOptionalTrimmedString(details.mode) ?? "unknown";
+  const artifactPath = readOptionalTrimmedString(details.artifactPath);
+  const results = Array.isArray(details.results) ? details.results.flatMap(normalizeDelegationResult).slice(0, SUBAGENT_RESULT_LIMIT) : [];
+  if (results.length === 0 && !artifactPath) {
+    return void 0;
   }
+  const resultLines = results.map(
+    (result) => `- ${result.agent}${result.name ? `/${result.name}` : ""}: ${result.status}${result.summary ? ` - ${result.summary}` : ""}`
+  );
+  const outcome = truncateText(
+    [
+      `mode=${mode}`,
+      ...resultLines,
+      ...artifactPath ? [`artifact=${artifactPath}`] : [],
+      ...results.length >= SUBAGENT_RESULT_LIMIT ? ["additional subagent results omitted"] : []
+    ].join("\n"),
+    SUBAGENT_OUTCOME_MAX_CHARS
+  );
   return {
-    status: "budget_limited",
-    budgets: pruneBudget({
-      ...budget,
-      limitReason: budget.limitReason ?? limitReason,
-      limitedAt: budget.limitedAt ?? limitedAt
-    })
+    command: `subagent ${mode}`,
+    outcome,
+    observedAt
   };
 }
-function resolveBudgetLimitReason(budget) {
-  if (!budget) {
-    return void 0;
-  }
-  if (budget.tokenBudget !== void 0 && (budget.tokenUsed ?? 0) >= budget.tokenBudget) {
-    return "token";
-  }
-  if (budget.wallClockBudgetSeconds !== void 0 && (budget.wallClockUsedSeconds ?? 0) >= budget.wallClockBudgetSeconds) {
-    return "wall_clock";
+function normalizeDelegationResult(value) {
+  const record = isRecord(value) ? value : void 0;
+  if (!record) {
+    return [];
   }
-  if (budget.turnBudget !== void 0 && (budget.turnsUsed ?? 0) >= budget.turnBudget) {
-    return "turn";
+  const agent = readOptionalTrimmedString(record.agent);
+  const status = readOptionalTrimmedString(record.status);
+  if (!agent || !status) {
+    return [];
   }
-  return void 0;
+  const stdout = readOptionalTrimmedString(record.stdout);
+  const stderr = readOptionalTrimmedString(record.stderr);
+  const name = readOptionalTrimmedString(record.name);
+  const summary = firstMeaningfulLine(stdout ?? stderr);
+  return [
+    {
+      agent,
+      ...name ? { name } : {},
+      status,
+      ...summary ? { summary } : {}
+    }
+  ];
 }
-function addDelta(current, delta) {
-  if (delta === void 0) {
-    return current;
-  }
-  return (current ?? 0) + delta;
+function isExpectedSubagentFindingSkip(code) {
+  return code === "feature_disabled" || code === "missing_active_set" || code === "missing_scope" || code === "misconfigured";
 }
-function pruneBudget(budget) {
-  return Object.fromEntries(Object.entries(budget).filter(([, value]) => value !== void 0));
+function firstMeaningfulLine(value) {
+  const line = value?.split(/\r?\n/u).map((part) => part.trim()).find((part) => part.length > 0);
+  return line ? truncateText(line, 500) : void 0;
 }
-function pruneContinuation(continuation) {
-  if (!continuation) {
-    return void 0;
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
   }
-  const pruned = Object.fromEntries(Object.entries(continuation).filter(([, value]) => value !== void 0));
-  return Object.keys(pruned).length > 0 ? pruned : void 0;
+  return `${value.slice(0, Math.max(0, maxChars - 15)).trimEnd()} [truncated]`;
 }
 
-// src/app/working-memory/handlers/commit-applied-change.ts
-function isAppliedWorkingSetCommitFailure(result) {
-  return "kind" in result;
-}
-async function commitAppliedWorkingSetChange(repository, input) {
-  if (input.operation.type === "account_usage") {
-    const writeResult2 = await repository.patchWorkingSetUsage({
-      workingSetId: input.workingSetId,
-      expectedRevision: input.expectedRevision,
-      status: input.applied.status,
-      snapshot: input.applied.snapshot,
-      title: input.applied.title,
-      objective: input.applied.objective,
-      now: input.now
-    });
-    if (isWorkingSetWriteFailure(writeResult2)) {
-      return writeResult2;
-    }
-    return {
-      type: "usage_patch",
-      workingSet: writeResult2.workingSet
-    };
-  }
-  const writeResult = await repository.updateWorkingSet({
-    workingSetId: input.workingSetId,
-    expectedRevision: input.expectedRevision,
-    eventType: input.operation.type,
-    payload: {
-      operation: input.operation,
-      updateReason: input.updateReason
-    },
-    status: input.applied.status,
-    snapshot: input.applied.snapshot,
-    title: input.applied.title,
-    objective: input.applied.objective,
-    actor: input.actor,
-    source: input.source,
-    now: input.now
+// src/adapters/skeln/episode/shutdown-episode-write.ts
+function buildSkelnSessionShutdownEpisodeWork(params) {
+  const target = resolveSkelnSessionEpisodeTarget(params.context);
+  const shutdownWork = params.event.reason === "quit" ? writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger).finally(() => closeSkelnServicesAfterShutdown(params.servicesPromise)) : writeScopedSkelnShutdownEpisode(params.servicesPromise, target, params.logger);
+  return shutdownWork.catch((error) => {
+    logSkelnShutdownEpisodeFailure(error, params.logger);
   });
-  if (isWorkingSetWriteFailure(writeResult)) {
-    return writeResult;
-  }
-  return {
-    type: "semantic",
-    workingSet: writeResult.workingSet,
-    event: writeResult.event
-  };
 }
-
-// src/app/working-memory/handlers/prepare-external-mutation.ts
-async function handlePrepareExternalGoalMutation(params, repository, timestamp) {
-  if (!isTrustedHostMutationSource(params.source)) {
-    return createFailure("invalid_request", "prepare_external_goal_mutation is reserved for trusted host runtime paths.");
-  }
-  const selection = await selectWorkingSet(params, repository);
-  if (!selection.ok) {
-    if (selection.code === "missing_active_set") {
-      return {
-        ok: true,
-        action: "prepare_external_goal_mutation",
-        prepared: false,
-        events: []
-      };
-    }
-    return selection;
-  }
-  if (params.requireCheckpoint && !params.checkpoint && !selection.workingSet.snapshot.checkpoint) {
-    return createFailure("invalid_request", `Active goal requires a checkpoint before ${params.mutationKind}.`, {
-      workingSetId: selection.workingSet.id,
-      revision: selection.workingSet.revision,
-      mutationKind: params.mutationKind
-    });
+function scheduleSkelnSessionShutdownEpisodeWrite(params) {
+  const work = buildSkelnSessionShutdownEpisodeWork(params);
+  if (params.event.reason === "quit" && params.event.deferWork) {
+    params.event.deferWork(work);
+    return Promise.resolve();
   }
-  if (!isMutableWorkingSetStatus(selection.workingSet.status)) {
-    return {
-      ok: true,
-      action: "prepare_external_goal_mutation",
-      prepared: true,
-      workingSet: selection.workingSet,
-      events: []
-    };
+  if (params.event.reason === "quit") {
+    return work;
   }
-  const events = [];
-  let workingSet = selection.workingSet;
-  for (const { operation, updateReason } of resolvePrepareOperations(params)) {
-    const applied = applyOperation(workingSet, operation, updateReason);
-    if (!applied.ok) {
-      return applied;
-    }
-    const writeResult = await commitAppliedWorkingSetChange(repository, {
-      workingSetId: workingSet.id,
-      expectedRevision: workingSet.revision,
-      operation,
-      updateReason,
-      applied,
-      actor: params.actor,
-      source: params.source,
-      now: timestamp
-    });
-    if (isAppliedWorkingSetCommitFailure(writeResult)) {
-      return writeFailureToResult(workingSet.id, writeResult);
-    }
-    workingSet = writeResult.workingSet;
-    if (writeResult.type === "semantic") {
-      events.push(writeResult.event);
-    }
+  void work;
+  return Promise.resolve();
+}
+function logSkelnShutdownEpisodeFailure(error, logger) {
+  const log = logger ?? console;
+  log.warn(`[agenr] skeln shutdown episode failed: ${formatErrorMessage(error)}`);
+}
+async function closeSkelnServicesAfterShutdown(servicesPromise) {
+  try {
+    const services = await servicesPromise;
+    await services.close();
+  } catch {
   }
-  return {
-    ok: true,
-    action: "prepare_external_goal_mutation",
-    prepared: true,
-    workingSet,
-    events
-  };
 }
-function resolvePrepareOperations(params) {
-  const operations = [];
-  if (params.usage) {
-    operations.push({
-      operation: { type: "account_usage", usage: params.usage },
-      updateReason: params.updateReason ?? `Accounted progress before external goal mutation (${params.mutationKind}).`
-    });
+async function writeScopedSkelnShutdownEpisode(servicesPromise, target, logger) {
+  const services = await servicesPromise;
+  if (!isPluginEpisodeWriteEnabled(services.skelnConfig.memoryPolicy)) {
+    return;
   }
-  if (params.checkpoint) {
-    operations.push({
-      operation: { type: "merge_checkpoint", checkpoint: params.checkpoint },
-      updateReason: params.updateReason ?? `Recorded checkpoint before external goal mutation (${params.mutationKind}).`
-    });
+  await withEpisodeWriteGuard({ port: services.dreaming, dbPath: services.config.dbPath }, async () => writeSkelnShutdownEpisode({ target, services, logger }));
+  await runSkelnPostSessionLightDream(services, logger);
+}
+async function runSkelnPostSessionLightDream(services, logger) {
+  const log = logger ?? console;
+  try {
+    const result = await maybeRunLightDream(
+      { trigger: "post_session" },
+      {
+        port: services.dreaming,
+        dbPath: services.config.dbPath,
+        config: services.agenrConfig,
+        embedding: services.embedding,
+        ...services.claimExtraction ? { createClaimExtractionLlm: () => services.claimExtraction.llm } : {}
+      }
+    );
+    if (result.status === "ran") {
+      log.info(`[agenr] skeln shutdown light dream completed run=${result.result.runId}`);
+    } else if (result.reason === "run_in_progress" || result.reason === "episode_write_in_progress") {
+      log.info(`[agenr] skeln shutdown light dream skipped reason=${result.reason}`);
+    }
+  } catch (error) {
+    log.warn(`[agenr] skeln shutdown light dream failed: ${formatErrorMessage(error)}`);
   }
-  return operations;
 }
 
-// src/app/working-memory/handlers/update.ts
-async function handleUpdate(params, repository, timestamp) {
-  const operation = params.operation;
-  if (!operation) {
-    return createFailure("invalid_request", "agenr_work update requires a typed operation.");
-  }
-  if (isTrustedHostOnlyWorkingOperation(operation.type) && !isTrustedHostMutationSource(params.source)) {
-    return createFailure("invalid_request", `${operation.type} is reserved for trusted host runtime paths.`);
-  }
-  const updateReason = normalizeRequiredString(params.updateReason, "agenr_work update requires updateReason.");
-  if (!updateReason.ok) {
-    return updateReason;
-  }
-  const selection = await selectWorkingSet(params, repository);
-  if (!selection.ok) {
-    return selection;
-  }
-  const expectedRevision = resolveExpectedRevision(selection.workingSet.revision, params.expectedRevision, params.source);
-  if (!expectedRevision.ok) {
-    return expectedRevision;
-  }
-  if (!isMutableWorkingSetStatus(selection.workingSet.status)) {
-    return createFailure("terminal_status", `Working set ${selection.workingSet.id} is already ${selection.workingSet.status}.`, {
-      workingSetId: selection.workingSet.id,
-      status: selection.workingSet.status
-    });
-  }
-  const applied = applyOperation(selection.workingSet, operation, updateReason.value);
-  if (!applied.ok) {
-    return applied;
-  }
-  const writeResult = await commitAppliedWorkingSetChange(repository, {
-    workingSetId: selection.workingSet.id,
-    expectedRevision: expectedRevision.value,
-    operation,
-    updateReason: updateReason.value,
-    applied,
-    actor: params.actor,
-    source: params.source,
-    now: timestamp
-  });
-  if (isAppliedWorkingSetCommitFailure(writeResult)) {
-    return writeFailureToResult(selection.workingSet.id, writeResult);
-  }
+// src/app/features/capabilities.ts
+function resolveRuntimeCapabilities(featureFlags, input = {}) {
+  const sessionMemoryFlagEnabled = featureFlags.sessionTreeLineage || featureFlags.sessionTreeCompaction;
+  const sessionMemory = resolveRepositoryBackedCapability(sessionMemoryFlagEnabled, input.sessionMemoryRepository);
   return {
-    ok: true,
-    action: "update",
-    workingSet: writeResult.workingSet,
-    ...writeResult.type === "semantic" ? { event: writeResult.event } : {},
-    projection: createToolSuccessProjection(writeResult.workingSet, "update", timestamp)
+    workingMemory: resolveRepositoryBackedCapability(featureFlags.workingMemory, input.workingMemoryRepository),
+    sessionMemory,
+    shutdownEpisodes: sessionMemory === "enabled",
+    goalContinuation: resolveGoalContinuationCapability(featureFlags.goalContinuation, input.goalContinuationHostPort)
   };
 }
-
-// src/app/working-memory/ready.ts
-var WORKING_MEMORY_DISABLED_MESSAGE = "Working memory is disabled by the workingMemory feature flag.";
-var WORKING_MEMORY_MISCONFIGURED_MESSAGE = "Working memory is enabled, but no working-memory repository was wired into the runtime.";
-function workingMemoryNotReadyFailure(input) {
-  if (!input.featureEnabled) {
-    return createFailure("feature_disabled", WORKING_MEMORY_DISABLED_MESSAGE);
-  }
-  if (!input.repository) {
-    return createFailure("misconfigured", WORKING_MEMORY_MISCONFIGURED_MESSAGE);
+function resolveRepositoryBackedCapability(featureEnabled, repository) {
+  if (!featureEnabled) {
+    return "disabled";
   }
-  return null;
+  return repository ? "enabled" : "misconfigured";
 }
-
-// src/app/working-memory/service.ts
-function createWorkingMemoryService(featureFlags, deps = {}) {
-  const featureEnabled = featureFlags.workingMemory;
-  const repository = deps.repository;
-  const now = () => deps.now ? deps.now().toISOString() : (/* @__PURE__ */ new Date()).toISOString();
-  const readiness = () => workingMemoryNotReadyFailure({ featureEnabled, repository });
-  return {
-    async run(params) {
-      const notReady = readiness();
-      if (notReady) {
-        return notReady;
-      }
-      switch (params.action) {
-        case "get":
-          return handleGet(params, repository, now());
-        case "list":
-          return handleList(params, repository);
-        case "create":
-          return handleCreate(params, repository, now(), deps.sourceLabel);
-        case "update":
-          return handleUpdate(params, repository, now());
-        case "close":
-          return handleClose(params, repository, now());
-      }
-    },
-    async prepareExternalGoalMutation(params) {
-      const notReady = readiness();
-      if (notReady) {
-        return notReady;
-      }
-      return handlePrepareExternalGoalMutation(params, repository, now());
-    },
-    async renderProjection(input) {
-      const request = typeof input === "string" ? { sourceRef: input } : input;
-      if (!featureEnabled) {
-        return createWorkingContextStubProjection({
-          reason: "feature_disabled",
-          sourceRef: request.sourceRef
-        });
-      }
-      if (!repository) {
-        return createWorkingContextStubProjection({
-          reason: "misconfigured",
-          sourceRef: request.sourceRef
-        });
-      }
-      const selection = await selectWorkingSet({ workingSetId: request.workingSetId, scope: request.scope }, repository);
-      if (!selection.ok) {
-        return createWorkingContextStubProjection({
-          reason: selection.code === "ambiguous_scope" ? "ambiguous_scope" : "missing_active_set",
-          sourceRef: request.sourceRef
-        });
-      }
-      return createWorkingContextFullProjection(selection.workingSet, request.sourceRef);
-    }
-  };
+function resolveGoalContinuationCapability(featureEnabled, hostPort) {
+  if (!featureEnabled) {
+    return "disabled";
+  }
+  return hostPort ? "enabled" : "misconfigured";
 }
 
-// src/app/host-memory/create-host-memory-services.ts
-function createHostMemoryServices(featureFlags, options = {}) {
-  const workingMemory = createWorkingMemoryService(featureFlags, {
-    repository: options.workingMemoryRepository,
-    sourceLabel: options.workingMemorySourceLabel
-  });
+// src/app/features/runtime-policy.ts
+function resolveRuntimePolicy(featureFlags, input = {}) {
   return {
-    workingMemory,
-    goalContinuation: createGoalContinuationService(featureFlags, options.goalContinuationHostPort),
-    routeSessionMemoryTrigger: (event) => routeSessionMemoryTrigger(event, featureFlags, {
-      repository: options.sessionMemoryRepository,
-      workingMemory
-    })
+    featureFlags,
+    capabilities: resolveRuntimeCapabilities(featureFlags, {
+      workingMemoryRepository: input.workingMemoryRepository,
+      sessionMemoryRepository: input.sessionMemoryRepository,
+      goalContinuationHostPort: input.goalContinuationHostPort
+    }),
+    ...input.memoryPolicy ? { memoryPolicy: input.memoryPolicy } : {}
   };
 }
 
@@ -2518,13 +1209,13 @@ async function createAgenrSkelnServices(config = {}) {
     config,
     readSlotPolicies: (hostConfig) => hostConfig.memoryPolicy?.slotPolicies,
     resolveClaimExtraction: ({ agenrConfig }) => createClaimExtractionFromAgenrConfig(agenrConfig),
-    extend: ({ config: hostConfig, resolvedConfig, agenrConfig, runtimeServices }) => {
+    extend: async ({ config: hostConfig, resolvedConfig, agenrConfig, runtimeServices }) => {
       const featureFlags = resolveAgenrFeatureFlags({
         ...agenrConfig.features,
         ...hostConfig.featureFlags
       });
       const goalContinuationHostPort = void 0;
-      const hostMemory = createHostMemoryServices(featureFlags, {
+      const hostMemory = await createHostMemoryServices(featureFlags, {
         workingMemoryRepository: runtimeServices.workingMemoryRepository,
         sessionMemoryRepository: runtimeServices.sessionMemoryRepository,
         workingMemorySourceLabel: "skeln",
@@ -2650,10 +1341,7 @@ function registerAgenrSkelnFetchTool(skeln, servicesPromise, resolveScope) {
     label: "Agenr Fetch",
     description: "Fetch the full body and metadata for one durable memory entry by id or subject.",
     promptSnippet: "Use agenr_fetch after agenr_recall when you need the full entry body for an id shown in recall results.",
-    promptGuidelines: [
-      "Provide exactly one target selector: id or subject.",
-      "Prefer id from agenr_recall when preview_truncated=true or when exact wording matters."
-    ],
+    promptGuidelines: [MEMORY_DOCTRINE.update.targetSelector, MEMORY_DOCTRINE.fetch.preferId],
     parameters: toolSchema(FETCH_TOOL_PARAMETERS),
     execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
       try {
@@ -2904,13 +1592,9 @@ function registerAgenrSkelnRecallTool(skeln, servicesPromise, resolveScope) {
   skeln.registerTool({
     name: "agenr_recall",
     label: "Agenr Recall",
-    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for normal use, including exact facts, historical-state questions, time-bounded episode questions, and procedural questions.",
+    description: buildSkelnRecallToolDescription(),
     promptSnippet: "Use agenr_recall to retrieve durable memory, prior episode summaries, or canonical procedures from agenr.",
-    promptGuidelines: [
-      "Use focused natural-language queries instead of broad 'everything' searches.",
-      "Use mode=procedures for how-to or checklist questions, and mode=episodes for what-happened questions tied to time or sessions.",
-      "Use asOf when the user asks what was true at an earlier point in time."
-    ],
+    promptGuidelines: buildSkelnRecallToolGuidelines(),
     parameters: toolSchema(RECALL_TOOL_PARAMETERS),
     execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
       try {
@@ -2933,42 +1617,61 @@ function registerAgenrSkelnStoreTool(skeln, servicesPromise, resolveScope) {
   skeln.registerTool({
     name: "agenr_store",
     label: "Agenr Store",
-    description: "Store a new durable memory entry in agenr. Store only durable facts, decisions, preferences, lessons, milestones, and relationships that help a future Skeln session make a better decision.",
+    description: buildSkelnStoreToolDescription(),
     promptSnippet: "Use agenr_store to persist durable memory that should survive across Skeln sessions.",
-    promptGuidelines: [
-      "Do not store progress logs, plans, or data already canonical in git, tickets, calendars, signed docs, chat/email, or databases.",
-      "Store the durable takeaway, standing rule, preference, risk, lesson, or relationship instead of raw activity.",
-      "Use claimKey for slot-like facts that may be superseded later, such as versions, strategies, owners, or limits."
-    ],
+    promptGuidelines: buildStoreToolGuidelines(),
     parameters: toolSchema(STORE_TOOL_PARAMETERS),
     execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
       try {
         const params = parseStoreToolParams(rawParams, SKELN_PARAM_READER);
         const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
-        return toSkelnToolResult(
-          await runStoreMemoryTool(params, services, {
-            session: scope,
-            sourcePrefix: "skeln-session",
-            defaultSourceContext: "Stored via agenr_store from Skeln.",
-            extraDetails: { sessionKey: scope.sessionKey },
-            onWarning: (warning) => console.warn(`[agenr] tool=agenr_store session=${scope.sessionId} warning: ${warning}`)
-          })
-        );
+        const outcome = await runStoreMemoryTool(params, services, {
+          session: scope,
+          sourcePrefix: "skeln-session",
+          defaultSourceContext: "Stored via agenr_store from Skeln.",
+          extraDetails: { sessionKey: scope.sessionKey },
+          onWarning: (warning) => console.warn(`[agenr] tool=agenr_store session=${scope.sessionId} warning: ${warning}`)
+        });
+        triggerSkelnImportanceLightDream(services, outcome.details.status);
+        return toSkelnToolResult(outcome);
       } catch (error) {
         return toolFailureResult(error);
       }
     }
   });
 }
+function triggerSkelnImportanceLightDream(services, status) {
+  if (status !== "stored") {
+    return;
+  }
+  void maybeRunLightDream(
+    { trigger: "importance" },
+    {
+      port: services.dreaming,
+      dbPath: services.config.dbPath,
+      config: services.agenrConfig,
+      embedding: services.embedding,
+      ...services.claimExtraction ? { createClaimExtractionLlm: () => services.claimExtraction.llm } : {}
+    }
+  ).then((result) => {
+    if (result.status === "ran") {
+      console.info(`[agenr] skeln importance light dream completed run=${result.result.runId}`);
+    } else if (result.reason === "run_in_progress" || result.reason === "episode_write_in_progress") {
+      console.info(`[agenr] skeln importance light dream skipped reason=${result.reason}`);
+    }
+  }).catch((error) => {
+    console.warn(`[agenr] skeln importance light dream failed: ${formatErrorMessage(error)}`);
+  });
+}
 
 // src/adapters/skeln/tools/update.ts
 function registerAgenrSkelnUpdateTool(skeln, servicesPromise, resolveScope) {
   skeln.registerTool({
     name: "agenr_update",
     label: "Agenr Update",
-    description: "Update an existing memory entry in place. Supports importance, expiry, claimKey, validFrom, and validTo.",
+    description: buildUpdateToolDescription(),
     promptSnippet: "Use agenr_update to correct metadata on an existing durable memory entry.",
-    promptGuidelines: ["Provide exactly one target selector: id or subject.", "Use agenr_store with supersedes for substantive content replacement."],
+    promptGuidelines: buildUpdateToolGuidelines(),
     parameters: toolSchema(UPDATE_TOOL_PARAMETERS),
     execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
       try {
@@ -2992,7 +1695,8 @@ function registerAgenrSkelnUpdateTool(skeln, servicesPromise, resolveScope) {
               expiry: params.expiry,
               claimKey: params.claimKeyInput,
               validFrom: params.validFrom,
-              validTo: params.validTo
+              validTo: params.validTo,
+              project: params.project
             })
           }
         });
@@ -3830,6 +2534,8 @@ function registerAgenrSkelnMemory(skeln, options = {}) {
   const servicesPromise = createAgenrSkelnServices(config);
   const scopeTracker = createSkelnSessionScopeTracker();
   const sessionStartTracker = createSessionStartTracker();
+  const compactionPromptTracker = createCompactionPromptTracker();
+  const lifecycleIntakeTracker = createSessionLifecycleIntakeTracker();
   const lifecycle = skeln;
   const resolveScope = async (context) => resolveCurrentSkelnSessionScope(context, scopeTracker, options);
   void servicesPromise.catch((error) => {
@@ -3837,8 +2543,16 @@ function registerAgenrSkelnMemory(skeln, options = {}) {
   });
   registerAgenrSkelnTools(skeln, servicesPromise, resolveScope);
   registerAgenrSkelnFailureBoundary(lifecycle);
-  registerAgenrSkelnInjectionHooks(lifecycle, scopeTracker, servicesPromise, sessionStartTracker, resolveScope);
-  registerAgenrSkelnSessionMemoryHooks(lifecycle, scopeTracker, servicesPromise, resolveScope);
+  registerAgenrSkelnInjectionHooks(
+    lifecycle,
+    scopeTracker,
+    servicesPromise,
+    sessionStartTracker,
+    compactionPromptTracker,
+    lifecycleIntakeTracker,
+    resolveScope
+  );
+  registerAgenrSkelnSessionMemoryHooks(lifecycle, scopeTracker, servicesPromise, resolveScope, compactionPromptTracker, lifecycleIntakeTracker);
   registerAgenrSkelnSubagentFindingHooks(lifecycle, servicesPromise, resolveScope);
   return {
     executeWorkCommand: (context, params) => executeAgenrSkelnWorkCommand(servicesPromise, resolveScope, context, params)
@@ -3847,13 +2561,19 @@ function registerAgenrSkelnMemory(skeln, options = {}) {
 function extension(skeln) {
   registerAgenrSkelnMemory(skeln);
 }
-function registerAgenrSkelnInjectionHooks(skeln, scopeTracker, servicesPromise, sessionStartTracker, resolveScope) {
+function registerAgenrSkelnInjectionHooks(skeln, scopeTracker, servicesPromise, sessionStartTracker, compactionPromptTracker, lifecycleIntakeTracker, resolveScope) {
   skeln.on("session_start", async (event, context) => {
     try {
       const scope = await resolveScope(context);
-      rememberSkelnSessionStart(scopeTracker, sessionStartTracker, scope, event.previousSessionFile);
-      const services = await servicesPromise;
-      logSessionMemoryTriggerResult(await services.routeSessionMemoryTrigger(buildSkelnSessionStartTriggerEvent(scope, event)));
+      rememberSkelnSessionStart(scopeTracker, scope);
+      await lifecycleIntakeTracker.track(
+        scope.sessionId,
+        scope.sessionKey,
+        (async () => {
+          const services = await servicesPromise;
+          logSessionMemoryTriggerResult(await services.routeSessionMemoryTrigger(buildSkelnSessionStartTriggerEvent(scope, event)));
+        })()
+      );
     } catch (error) {
       console.warn(`[agenr] session_start scope failed: ${formatErrorMessage(error)}`);
     }
@@ -3863,32 +2583,65 @@ function registerAgenrSkelnInjectionHooks(skeln, scopeTracker, servicesPromise,
     async (event, context) => handleAgenrSkelnBeforeAgentStart(event, context, {
       servicesPromise,
       sessionStartTracker,
+      compactionPromptTracker,
+      lifecycleIntakeTracker,
       resolveScope
     })
   );
 }
-function registerAgenrSkelnSessionMemoryHooks(skeln, scopeTracker, servicesPromise, resolveScope) {
+function registerAgenrSkelnSessionMemoryHooks(skeln, scopeTracker, servicesPromise, resolveScope, compactionPromptTracker, lifecycleIntakeTracker) {
   skeln.on("session_before_fork", async (event, context) => {
-    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeForkTriggerEvent(scope, event));
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(
+      scope.sessionId,
+      scope.sessionKey,
+      routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope2) => buildSkelnSessionBeforeForkTriggerEvent(scope2, event))
+    );
   });
-  skeln.on("session_before_compact", async (_event, context) => {
-    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeCompactTriggerEvent(scope));
+  skeln.on("session_before_compact", async (event, context) => {
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(scope.sessionId, scope.sessionKey, handleSkelnSessionBeforeCompact(event, context, servicesPromise, resolveScope));
   });
   skeln.on("session_compact", async (event, context) => {
-    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionCompactTriggerEvent(scope, event));
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(
+      scope.sessionId,
+      scope.sessionKey,
+      routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope2) => buildSkelnSessionCompactTriggerEvent(scope2, event))
+    );
   });
   skeln.on("session_before_tree", async (event, context) => {
-    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeTreeTriggerEvent(scope, event));
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(
+      scope.sessionId,
+      scope.sessionKey,
+      routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope2) => buildSkelnSessionBeforeTreeTriggerEvent(scope2, event))
+    );
   });
   skeln.on("session_tree", async (event, context) => {
-    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionTreeTriggerEvent(scope, event));
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(
+      scope.sessionId,
+      scope.sessionKey,
+      routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope2) => buildSkelnSessionTreeTriggerEvent(scope2, event))
+    );
   });
   skeln.on("session_shutdown", async (event, context) => {
-    await handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context);
+    await handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context, compactionPromptTracker, lifecycleIntakeTracker);
   });
 }
-async function handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context) {
-  await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionShutdownTriggerEvent(scope, event));
+async function handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context, compactionPromptTracker, lifecycleIntakeTracker) {
+  try {
+    const scope = await resolveScope(context);
+    await lifecycleIntakeTracker.track(
+      scope.sessionId,
+      scope.sessionKey,
+      routeSkelnSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope2) => buildSkelnSessionShutdownTriggerEvent(scope2, event))
+    );
+    compactionPromptTracker.clear(scope.sessionId, scope.sessionKey);
+    await lifecycleIntakeTracker.clear(scope.sessionId, scope.sessionKey);
+  } catch {
+  }
   clearTrackedSkelnScope(scopeTracker, context);
   await scheduleSkelnSessionShutdownEpisodeWrite({ event, context, servicesPromise });
 }
@@ -3898,15 +2651,6 @@ function registerAgenrSkelnSubagentFindingHooks(skeln, servicesPromise, resolveS
     return void 0;
   });
 }
-async function routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, buildEvent) {
-  try {
-    const scope = await resolveScope(context);
-    const services = await servicesPromise;
-    logSessionMemoryTriggerResult(await services.routeSessionMemoryTrigger(buildEvent(scope)));
-  } catch (error) {
-    console.warn(`[agenr] session-memory trigger failed: ${formatErrorMessage(error)}`);
-  }
-}
 async function resolveCurrentSkelnSessionScope(context, scopeTracker, options) {
   const sessionId = String(context.sessionManager.getSessionId());
   const tracked = scopeTracker.getSessionScope(sessionId);
@@ -3924,9 +2668,8 @@ async function resolveCurrentSkelnSessionScope(context, scopeTracker, options) {
   const override = options.getHostContext ? await options.getHostContext(context) : void 0;
   return toSkelnSessionScope(mergeSkelnHostContext(defaults, override), sessionId);
 }
-function rememberSkelnSessionStart(scopeTracker, sessionStartTracker, scope, previousSessionFile) {
+function rememberSkelnSessionStart(scopeTracker, scope) {
   scopeTracker.rememberSessionStart(scope);
-  sessionStartTracker.rememberSessionStart(scope.sessionId, scope.sessionKey, previousSessionFile);
 }
 function resolveContextCwd(context) {
   return context.cwd || context.sessionManager.getCwd();