agenr 2.0.1 → 3.0.0

package/dist/adapters/skeln/index.js

@@ -0,0 +1,3899 @@
+import {
+  CLOSE_EVENT_HISTORY_LIMIT,
+  EPISODE_SUMMARY_TIMEOUT_MS,
+  RECALL_TOOL_PARAMETERS,
+  SESSION_LINEAGE_REASONS,
+  STORE_TOOL_PARAMETERS,
+  UPDATE_TOOL_PARAMETERS,
+  WORKING_CANDIDATE_PROMOTION_STATUSES,
+  asRecord,
+  buildRecallToolServices,
+  composeHostPluginServices,
+  createClaimExtractionFromAgenrConfig,
+  createDeadlineAwareEpisodeSummaryLlm,
+  createSessionStartTracker,
+  embedEpisodeSummaryWithinBudget,
+  extractRecentTurnsFromMessages,
+  formatAgenrSessionStartRecall,
+  formatErrorMessage,
+  formatTargetSelector,
+  formatUnifiedRecallResults,
+  isCloseManagedStatus,
+  isModelVisibleOperationType,
+  isMutableWorkingSetStatus,
+  isTrustedHostMutationSource,
+  isTrustedHostOnlyWorkingOperation,
+  normalizeEventLimit,
+  normalizeListLimit,
+  normalizeOptionalString,
+  normalizePluginInjectionMemoryPolicyConfig,
+  normalizePromptText,
+  parseRecallToolParams,
+  parseStoreToolParams,
+  parseUpdateToolParams,
+  resolveBeforeTurnPolicy,
+  resolveSessionIdentityKey,
+  resolveSessionStartPolicy,
+  resolveWorkingContextGate,
+  runRecallMemoryTool,
+  runSessionStart,
+  runStoreMemoryTool,
+  runUpdateMemoryTool,
+  sanitizeUpdateToolParams,
+  writeBoundedSingleTranscriptEpisode
+} from "../../chunk-MYZ2CWY6.js";
+import {
+  createSingleTranscriptDiscoveryPort
+} from "../../chunk-LAXNNWHM.js";
+import {
+  buildRecallToolDetails,
+  formatAgenrBeforeTurnRecall,
+  runBeforeTurn
+} from "../../chunk-575MUIW5.js";
+import {
+  AGENR_FEATURE_FLAG_KEYS,
+  DEFAULT_AGENR_FEATURE_FLAGS,
+  createLlmClient,
+  isRecord,
+  readOptionalFiniteNumber,
+  readOptionalTrimmedString,
+  resolveLlmApiKey,
+  resolveModel
+} from "../../chunk-ELR2HSVC.js";
+import "../../chunk-5LADPJ4C.js";
+
+// src/adapters/skeln/config.ts
+function parseSkelnMemoryPolicyJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const normalized = normalizePluginInjectionMemoryPolicyConfig(parsed);
+    if (!normalized.ok) {
+      return { ok: false, error: normalized.errors.join("; ") };
+    }
+    return { ok: true, value: normalized.value };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: `memoryPolicy must be valid JSON: ${message}` };
+  }
+}
+function readSkelnMemoryPolicySetting(skeln) {
+  const value = skeln.getSetting("memoryPolicy");
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return { ok: false, error: "memoryPolicy must be a non-empty JSON string when provided" };
+  }
+  return parseSkelnMemoryPolicyJson(value.trim());
+}
+function mergeSkelnMemoryPolicy(fromSettings, fromOptions) {
+  if (!fromSettings) {
+    return fromOptions;
+  }
+  if (!fromOptions) {
+    return fromSettings;
+  }
+  const slotPolicies = mergeSlotPolicies(fromSettings.slotPolicies, fromOptions.slotPolicies);
+  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) {
+    return void 0;
+  }
+  return {
+    ...slotPolicies ? { slotPolicies } : {},
+    ...sessionStart ? { sessionStart } : {},
+    ...beforeTurn ? { beforeTurn } : {},
+    ...workingContext ? { workingContext } : {}
+  };
+}
+function mergeSlotPolicies(fromSettings, fromOptions) {
+  if (!fromSettings) {
+    return fromOptions;
+  }
+  if (!fromOptions) {
+    return fromSettings;
+  }
+  const attributeHeads = fromSettings.attributeHeads || fromOptions.attributeHeads ? {
+    ...fromSettings.attributeHeads,
+    ...fromOptions.attributeHeads
+  } : void 0;
+  if (!attributeHeads) {
+    return void 0;
+  }
+  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();
+  const normalizedCwd = cwd.trim();
+  if (!normalizedSessionId) {
+    throw new Error("Skeln session id is required to derive a session key.");
+  }
+  if (!normalizedCwd) {
+    return `skeln:session:${normalizedSessionId}`;
+  }
+  return `skeln:session:${normalizedSessionId}:cwd:${normalizedCwd}`;
+}
+function normalizeSkelnScopeField(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function buildSkelnHostContext(input) {
+  const cwd = input.cwd.trim();
+  if (!cwd) {
+    throw new Error("Skeln cwd is required to build host context.");
+  }
+  const gitRoot = normalizeSkelnScopeField(input.gitRoot);
+  const gitBranch = normalizeSkelnScopeField(input.gitBranch);
+  const project = normalizeSkelnScopeField(input.project);
+  return {
+    cwd,
+    sessionKey: resolveSkelnSessionKey(input.sessionId, cwd),
+    conversationKey: input.sessionId.trim(),
+    ...gitRoot ? { gitRoot } : {},
+    ...gitBranch ? { gitBranch } : {},
+    ...project ? { project } : {}
+  };
+}
+function mergeSkelnHostContext(defaults, override) {
+  if (!override) {
+    return defaults;
+  }
+  const merged = {
+    cwd: normalizeSkelnScopeField(override.cwd) ?? defaults.cwd,
+    sessionKey: normalizeSkelnScopeField(override.sessionKey) ?? defaults.sessionKey,
+    conversationKey: normalizeSkelnScopeField(override.conversationKey) ?? defaults.conversationKey
+  };
+  const gitRoot = normalizeSkelnScopeField(override.gitRoot) ?? defaults.gitRoot;
+  if (gitRoot) {
+    merged.gitRoot = gitRoot;
+  }
+  const gitBranch = normalizeSkelnScopeField(override.gitBranch) ?? defaults.gitBranch;
+  if (gitBranch) {
+    merged.gitBranch = gitBranch;
+  }
+  const project = normalizeSkelnScopeField(override.project) ?? defaults.project;
+  if (project) {
+    merged.project = project;
+  }
+  return merged;
+}
+function toSkelnSessionScope(hostContext, sessionId) {
+  const normalizedSessionId = sessionId.trim();
+  if (!normalizedSessionId) {
+    throw new Error("Skeln session id is required to build session scope.");
+  }
+  return {
+    sessionId: normalizedSessionId,
+    sessionKey: hostContext.sessionKey,
+    cwd: hostContext.cwd,
+    conversationKey: hostContext.conversationKey ?? normalizedSessionId,
+    ...hostContext.gitRoot ? { gitRoot: hostContext.gitRoot } : {},
+    ...hostContext.gitBranch ? { gitBranch: hostContext.gitBranch } : {},
+    ...hostContext.project ? { project: hostContext.project } : {}
+  };
+}
+function toWorkingScopeFromSkelnSession(scope) {
+  return {
+    sessionId: scope.sessionId,
+    conversationKey: scope.conversationKey ?? scope.sessionId,
+    cwd: scope.cwd,
+    ...scope.gitRoot ? { gitRoot: scope.gitRoot } : {},
+    ...scope.gitBranch ? { gitBranch: scope.gitBranch } : {},
+    ...scope.project ? { project: scope.project } : {}
+  };
+}
+
+// src/adapters/skeln/session/branch-compaction.ts
+function extractSkelnBeforeTurnBranchMessages(branch) {
+  return selectEntriesAfterLatestCompaction(branch).flatMap((entry) => isSkelnMessageEntry(entry) ? [entry.message] : []);
+}
+function selectEntriesAfterLatestCompaction(branch) {
+  const latestCompaction = findLatestCompactionEntry(branch);
+  if (!latestCompaction) {
+    return branch;
+  }
+  const firstKeptEntryId = typeof latestCompaction.firstKeptEntryId === "string" ? latestCompaction.firstKeptEntryId.trim() : "";
+  if (!firstKeptEntryId) {
+    return branch;
+  }
+  const keptStart = branch.findIndex((entry) => entry.id === firstKeptEntryId);
+  const compactionIndex = branch.findIndex((entry) => entry === latestCompaction);
+  if (keptStart < 0 || compactionIndex < 0 || keptStart >= compactionIndex) {
+    return branch;
+  }
+  return branch.slice(keptStart, compactionIndex).concat(branch.slice(compactionIndex + 1));
+}
+function findLatestCompactionEntry(branch) {
+  for (let index = branch.length - 1; index >= 0; index -= 1) {
+    const entry = branch[index];
+    if (entry?.type === "compaction") {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function isSkelnMessageEntry(entry) {
+  if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") {
+    return false;
+  }
+  const role = entry.message.role;
+  return role === "user" || role === "assistant" || role === "system" || role === "tool";
+}
+
+// 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.",
+    "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.",
+    ""
+  ];
+}
+
+// src/adapters/skeln/memory-trace.ts
+var AGENR_MEMORY_DOCTRINE_HEADER = "## Memory Recall";
+function traceMemoryInjected(kind, input) {
+  return {
+    kind,
+    action: "injected",
+    ...input.bytes !== void 0 ? { bytes: input.bytes } : {},
+    ...input.summary ? { summary: input.summary } : {},
+    ...input.preview ? { preview: input.preview } : {},
+    ...input.workingSetId ? { workingSetId: input.workingSetId } : {},
+    ...input.revision !== void 0 ? { revision: input.revision } : {},
+    ...input.sourceRef ? { sourceRef: input.sourceRef } : {}
+  };
+}
+function traceMemorySkipped(kind, reason, summary) {
+  return {
+    kind,
+    action: "skipped",
+    reason,
+    ...summary ? { summary } : {}
+  };
+}
+function traceMemoryFailed(kind, reason) {
+  return {
+    kind,
+    action: "failed",
+    reason
+  };
+}
+function buildBeforeAgentStartMemoryTrace(input) {
+  const recallText = input.recallText?.trim();
+  const hasRecall = recallText !== void 0 && recallText.length > 0;
+  const memoryTrace = [];
+  if (input.baseSystemPrompt !== void 0 && input.systemPrompt !== void 0) {
+    const doctrineTrace = traceSystemPromptDoctrineInjected(input.baseSystemPrompt, input.systemPrompt);
+    if (doctrineTrace) {
+      memoryTrace.push(doctrineTrace);
+    }
+  }
+  if (input.workingContextTrace) {
+    memoryTrace.push(input.workingContextTrace);
+  }
+  if (input.recallKind) {
+    if (input.recallFailureReason) {
+      memoryTrace.push(traceMemoryFailed(input.recallKind, input.recallFailureReason));
+    } else if (input.recallSkippedReason) {
+      memoryTrace.push(traceMemorySkipped(input.recallKind, input.recallSkippedReason));
+    } else if (hasRecall && recallText) {
+      memoryTrace.push(
+        traceMemoryInjected(input.recallKind, {
+          bytes: recallText.length,
+          summary: input.recallKind === "session_start_recall" ? "session-start recall injected" : "before-turn recall injected",
+          preview: recallText
+        })
+      );
+    } else {
+      memoryTrace.push(traceMemorySkipped(input.recallKind, "no matching entries"));
+    }
+  }
+  return memoryTrace;
+}
+function traceWorkingContextInjected(audit, content) {
+  return traceMemoryInjected("working_context", {
+    bytes: audit?.bytes ?? content.length,
+    summary: audit?.summary,
+    preview: content,
+    workingSetId: audit?.workingSetId,
+    revision: audit?.revision,
+    sourceRef: audit?.sourceRef
+  });
+}
+function traceSystemPromptDoctrineInjected(baseSystemPrompt, updatedSystemPrompt) {
+  if (updatedSystemPrompt === baseSystemPrompt || !updatedSystemPrompt.includes(AGENR_MEMORY_DOCTRINE_HEADER)) {
+    return void 0;
+  }
+  const doctrineIndex = updatedSystemPrompt.indexOf(AGENR_MEMORY_DOCTRINE_HEADER);
+  const doctrine = doctrineIndex === -1 ? "" : updatedSystemPrompt.slice(doctrineIndex).trim();
+  return traceMemoryInjected("system_prompt", {
+    bytes: doctrine.length,
+    summary: "agenr memory doctrine appended",
+    preview: doctrine
+  });
+}
+
+// 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) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: content }],
+    timestamp: Date.now()
+  };
+}
+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
+      });
+    }
+    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
+    });
+  } 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
+    });
+  }
+  const currentTurnText = normalizePromptText(event.prompt);
+  if (!currentTurnText) {
+    return composeSkelnBeforeAgentStartResult({
+      baseSystemPrompt,
+      systemPrompt,
+      recallKind: "before_turn_recall",
+      recallSkippedReason: "empty turn prompt",
+      workingInjection
+    });
+  }
+  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
+    });
+  }
+}
+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 {
+    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 } : {}
+  };
+}
+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 loadWorkingContextProjection(services, scope, sourceRef);
+}
+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) };
+  }
+}
+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/adapters/skeln/hooks/session-memory.ts
+var LINEAGE_SESSION_START_REASONS = /* @__PURE__ */ new Set(["fork", "clone", "resume"]);
+function buildSkelnSessionStartTriggerEvent(scope, transition = {}) {
+  const previousSessionFile = transition.previousSessionFile?.trim();
+  const transitionReason = resolveSessionStartTransitionReason(transition.reason, previousSessionFile);
+  const predecessor = buildSessionStartPredecessor(transitionReason, previousSessionFile);
+  return {
+    type: "session_start",
+    sessionKey: scope.sessionKey,
+    childSessionKey: scope.sessionKey,
+    transitionReason,
+    ...predecessor ? { predecessor } : {},
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionBeforeForkTriggerEvent(scope, event) {
+  const forkEntryId = event.entryId?.trim();
+  return {
+    type: "session_before_fork",
+    sessionKey: scope.sessionKey,
+    ...forkEntryId ? {
+      predecessor: {
+        forkEntryId,
+        forkPosition: event.position
+      }
+    } : {},
+    payload: event,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionBeforeCompactTriggerEvent(scope) {
+  return {
+    type: "session_before_compact",
+    sessionKey: scope.sessionKey,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionCompactTriggerEvent(scope, event) {
+  const compactionEntry = event.compactionEntry;
+  return {
+    type: "session_compact",
+    sessionKey: scope.sessionKey,
+    artifact: buildCompactionCheckpointArtifact(scope.sessionKey, compactionEntry, event.fromExtension),
+    workingScope: toWorkingScopeFromSkelnSession(scope),
+    payload: event,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionBeforeTreeTriggerEvent(scope, event) {
+  return {
+    type: "session_before_tree",
+    sessionKey: scope.sessionKey,
+    payload: event,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionTreeTriggerEvent(scope, event) {
+  const summaryEntry = event.summaryEntry;
+  const artifact = summaryEntry ? {
+    kind: "branch_abandonment",
+    source: "skeln",
+    sourceId: summaryEntry.id,
+    sourceRef: `branch_summary:${summaryEntry.id}`,
+    summary: summaryEntry.summary,
+    metadata: {
+      fromId: summaryEntry.fromId,
+      oldLeafId: event.oldLeafId,
+      newLeafId: event.newLeafId,
+      ...event.fromExtension !== void 0 ? { fromExtension: event.fromExtension } : {}
+    }
+  } : void 0;
+  return {
+    type: "session_tree",
+    sessionKey: scope.sessionKey,
+    ...artifact ? { artifact } : {},
+    payload: event,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildSkelnSessionShutdownTriggerEvent(scope, event) {
+  return {
+    type: "session_shutdown",
+    sessionKey: scope.sessionKey,
+    workingScope: toWorkingScopeFromSkelnSession(scope),
+    shutdownReason: event.reason,
+    payload: 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;
+  }
+  return previousSessionFile ? "resume" : "new";
+}
+function isLineageSessionStartReason(reason) {
+  return reason !== void 0 && LINEAGE_SESSION_START_REASONS.has(reason);
+}
+function buildSessionStartPredecessor(transitionReason, previousSessionFile) {
+  if (transitionReason === "new") {
+    return void 0;
+  }
+  const sourceRef = previousSessionFile?.trim();
+  if (!sourceRef) {
+    return void 0;
+  }
+  return { sourceRef };
+}
+function buildCompactionCheckpointArtifact(sessionKey, compactionEntry, fromExtension) {
+  return {
+    kind: "compaction_checkpoint",
+    sessionKey,
+    source: "skeln",
+    sourceId: compactionEntry.id,
+    sourceRef: `compaction:${compactionEntry.id}`,
+    summary: compactionEntry.summary,
+    metadata: {
+      firstKeptEntryId: compactionEntry.firstKeptEntryId,
+      fromExtension
+    }
+  };
+}
+
+// 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"
+    });
+    if (!result.ok && !isExpectedSubagentFindingSkip(result.code)) {
+      console.warn(`[agenr] subagent findings working-memory update failed: ${result.message}`);
+    }
+  } catch (error) {
+    console.warn(`[agenr] subagent findings capture failed: ${formatErrorMessage(error)}`);
+  }
+}
+function buildSkelnSubagentCommandNote(event, observedAt) {
+  if (event.toolName !== "subagent" || event.isError) {
+    return void 0;
+  }
+  const details = isRecord(event.details) ? event.details : void 0;
+  if (!details) {
+    return void 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;
+  }
+  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
+async function writeSkelnBoundedSessionEpisode(params) {
+  const logger = params.logger ?? console;
+  const sessionFile = resolveSessionFile(params.context);
+  const sessionId = String(params.context.sessionManager.getSessionId());
+  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) {
+  const sessionId = String(params.context.sessionManager.getSessionId());
+  await writeSkelnBoundedSessionEpisode({
+    context: params.context,
+    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=${sessionId} key=skeln:${sessionId}`,
+    skipDetails: `session=${sessionId}`
+  });
+}
+
+// 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.`;
+}
+function invalidEvent(message) {
+  return {
+    accepted: false,
+    reason: "invalid_event",
+    message
+  };
+}
+function isCheckpointRelevantTrigger(type) {
+  return type === "session_before_fork" || type === "session_before_compact" || type === "session_before_tree" || type === "session_shutdown";
+}
+
+// src/app/working-memory/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"
+    });
+  }
+  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;
+}
+
+// src/app/working-memory/results.ts
+function createFailure(code, message, details) {
+  return {
+    ok: false,
+    code,
+    message,
+    ...details ? { details } : {}
+  };
+}
+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 } : {}
+      });
+  }
+}
+
+// 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)
+    });
+  }
+  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
+    });
+  }
+  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.");
+  }
+  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 };
+}
+
+// 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."
+    );
+  }
+  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
+    });
+  }
+  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);
+  }
+  return {
+    ok: true,
+    action: "close",
+    workingSet: writeResult.workingSet,
+    event: writeResult.event,
+    candidates
+  };
+}
+
+// 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);
+  }
+  return readGoalGeneration(snapshot) + 1;
+}
+
+// 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
+    });
+  }
+  return {
+    ok: true,
+    scope: lookup.scope
+  };
+}
+
+// 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
+    });
+  }
+  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;
+    }
+    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;
+  }
+  return {
+    ok: true,
+    snapshot,
+    status,
+    title,
+    objective
+  };
+}
+function mergeBudgetState(current, update) {
+  const validation = validateWorkingBudgetState(update);
+  if (!validation.ok) {
+    return validation;
+  }
+  return {
+    ok: true,
+    value: pruneBudget({
+      ...current ?? {},
+      ...update
+    })
+  };
+}
+function applyUsageDelta(current, usage, limitedAt) {
+  const validation = validateWorkingUsageDelta(usage);
+  if (!validation.ok) {
+    return validation;
+  }
+  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 };
+  }
+  return {
+    status: "budget_limited",
+    budgets: pruneBudget({
+      ...budget,
+      limitReason: budget.limitReason ?? limitReason,
+      limitedAt: budget.limitedAt ?? limitedAt
+    })
+  };
+}
+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";
+  }
+  if (budget.turnBudget !== void 0 && (budget.turnsUsed ?? 0) >= budget.turnBudget) {
+    return "turn";
+  }
+  return void 0;
+}
+function addDelta(current, delta) {
+  if (delta === void 0) {
+    return current;
+  }
+  return (current ?? 0) + delta;
+}
+function pruneBudget(budget) {
+  return Object.fromEntries(Object.entries(budget).filter(([, value]) => value !== void 0));
+}
+function pruneContinuation(continuation) {
+  if (!continuation) {
+    return void 0;
+  }
+  const pruned = Object.fromEntries(Object.entries(continuation).filter(([, value]) => value !== void 0));
+  return Object.keys(pruned).length > 0 ? pruned : void 0;
+}
+
+// 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
+  });
+  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
+    });
+  }
+  if (!isMutableWorkingSetStatus(selection.workingSet.status)) {
+    return {
+      ok: true,
+      action: "prepare_external_goal_mutation",
+      prepared: true,
+      workingSet: selection.workingSet,
+      events: []
+    };
+  }
+  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);
+    }
+  }
+  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}).`
+    });
+  }
+  if (params.checkpoint) {
+    operations.push({
+      operation: { type: "merge_checkpoint", checkpoint: params.checkpoint },
+      updateReason: params.updateReason ?? `Recorded checkpoint before external goal mutation (${params.mutationKind}).`
+    });
+  }
+  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);
+  }
+  return {
+    ok: true,
+    action: "update",
+    workingSet: writeResult.workingSet,
+    ...writeResult.type === "semantic" ? { event: writeResult.event } : {},
+    projection: createToolSuccessProjection(writeResult.workingSet, "update", timestamp)
+  };
+}
+
+// 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);
+  }
+  return null;
+}
+
+// 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);
+    }
+  };
+}
+
+// src/app/host-memory/create-host-memory-services.ts
+function createHostMemoryServices(featureFlags, options = {}) {
+  const workingMemory = createWorkingMemoryService(featureFlags, {
+    repository: options.workingMemoryRepository,
+    sourceLabel: options.workingMemorySourceLabel
+  });
+  return {
+    workingMemory,
+    goalContinuation: createGoalContinuationService(featureFlags, options.goalContinuationHostPort),
+    routeSessionMemoryTrigger: (event) => routeSessionMemoryTrigger(event, featureFlags, {
+      repository: options.sessionMemoryRepository,
+      workingMemory
+    })
+  };
+}
+
+// src/app/skeln/runtime.ts
+async function createAgenrSkelnServices(config = {}) {
+  return composeHostPluginServices({
+    config,
+    readSlotPolicies: (hostConfig) => hostConfig.memoryPolicy?.slotPolicies,
+    resolveClaimExtraction: ({ agenrConfig }) => createClaimExtractionFromAgenrConfig(agenrConfig),
+    extend: ({ config: hostConfig, resolvedConfig, agenrConfig, runtimeServices }) => {
+      const featureFlags = resolveAgenrFeatureFlags({
+        ...agenrConfig.features,
+        ...hostConfig.featureFlags
+      });
+      const goalContinuationHostPort = void 0;
+      const hostMemory = createHostMemoryServices(featureFlags, {
+        workingMemoryRepository: runtimeServices.workingMemoryRepository,
+        sessionMemoryRepository: runtimeServices.sessionMemoryRepository,
+        workingMemorySourceLabel: "skeln",
+        goalContinuationHostPort
+      });
+      const runtimePolicy = resolveRuntimePolicy(featureFlags, {
+        workingMemoryRepository: runtimeServices.workingMemoryRepository,
+        sessionMemoryRepository: runtimeServices.sessionMemoryRepository,
+        memoryPolicy: hostConfig.memoryPolicy,
+        goalContinuationHostPort
+      });
+      return {
+        ...runtimeServices,
+        ...hostMemory,
+        capabilities: runtimePolicy.capabilities,
+        runtimePolicy,
+        config: resolvedConfig,
+        skelnConfig: hostConfig,
+        agenrConfig
+      };
+    }
+  });
+}
+
+// src/adapters/skeln/session/state.ts
+function createSkelnSessionScopeTracker() {
+  const scopesByIdentity = /* @__PURE__ */ new Map();
+  return {
+    rememberSessionStart(scope) {
+      const identityKey = resolveSessionIdentityKey(scope.sessionId, scope.sessionKey);
+      if (!identityKey) {
+        return;
+      }
+      scopesByIdentity.set(identityKey, scope);
+    },
+    getSessionScope(sessionId) {
+      const normalizedSessionId = sessionId.trim();
+      if (!normalizedSessionId) {
+        return void 0;
+      }
+      return scopesByIdentity.get(`session:${normalizedSessionId}`);
+    },
+    clear(sessionId, sessionKey) {
+      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
+      return identityKey ? scopesByIdentity.delete(identityKey) : false;
+    }
+  };
+}
+
+// src/adapters/shared/goal-tool-presentations.ts
+var COMPLETION_BUDGET_REPORT = "Goal achieved. Report final usage from this tool result's structured goal fields. If `goal.tokenBudget` is present, include token usage from `goal.tokensUsed` and `goal.tokenBudget`. If `goal.timeUsedSeconds` is greater than 0, summarize elapsed time in a concise, human-friendly form appropriate to the response language.";
+function toGoalToolGoal(workingSet) {
+  const budgets = workingSet.snapshot.budgets;
+  return {
+    workingSetId: workingSet.id,
+    revision: workingSet.revision,
+    goalGeneration: readGoalGeneration(workingSet.snapshot),
+    objective: workingSet.snapshot.objective ?? workingSet.objective ?? "",
+    status: workingSet.status,
+    ...budgets?.tokenBudget !== void 0 ? { tokenBudget: budgets.tokenBudget } : {},
+    tokensUsed: budgets?.tokenUsed ?? 0,
+    timeUsedSeconds: budgets?.wallClockUsedSeconds ?? 0,
+    ...workingSet.snapshot.checkpoint ? { checkpoint: workingSet.snapshot.checkpoint } : {},
+    ...workingSet.snapshot.continuation?.policy ? { continuationPolicy: workingSet.snapshot.continuation.policy } : {},
+    ...workingSet.snapshot.continuation?.resumeAfter ? { resumeAfter: workingSet.snapshot.continuation.resumeAfter } : {},
+    ...workingSet.snapshot.continuation?.staleAfter ? { staleAfter: workingSet.snapshot.continuation.staleAfter } : {},
+    ...budgets?.limitReason ? { budgetLimitReason: budgets.limitReason } : {},
+    ...budgets?.turnBudget !== void 0 ? { turnBudget: budgets.turnBudget } : {},
+    turnsUsed: budgets?.turnsUsed ?? 0,
+    createdAt: workingSet.createdAt,
+    updatedAt: workingSet.updatedAt
+  };
+}
+function toGoalToolResponse(workingSet, includeCompletionReport) {
+  if (!workingSet) {
+    return {
+      goal: null,
+      remainingTokens: null,
+      completionBudgetReport: null
+    };
+  }
+  const budgets = workingSet.snapshot.budgets;
+  const goal = toGoalToolGoal(workingSet);
+  return {
+    goal,
+    remainingTokens: budgets?.tokenBudget !== void 0 ? Math.max(budgets.tokenBudget - goal.tokensUsed, 0) : null,
+    completionBudgetReport: includeCompletionReport && hasUsageToReport(goal) ? COMPLETION_BUDGET_REPORT : null
+  };
+}
+function hasUsageToReport(goal) {
+  return goal.tokenBudget !== void 0 || goal.timeUsedSeconds > 0;
+}
+
+// src/adapters/shared/goal-tools.ts
+var GET_GOAL_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+var CREATE_GOAL_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    objective: {
+      type: "string",
+      description: "Required. The concrete objective to start pursuing. This starts a new active goal only when no goal is currently defined; if a goal already exists, this tool fails."
+    },
+    token_budget: {
+      type: "integer",
+      minimum: 1,
+      description: "Positive token budget for the new goal. Omit unless explicitly requested."
+    }
+  },
+  required: ["objective"]
+};
+var UPDATE_GOAL_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    status: {
+      type: "string",
+      enum: ["complete", "blocked"],
+      description: "Required. Set to complete only when the objective is achieved and no required work remains. Set to blocked only after the same blocking condition has recurred for at least three consecutive goal turns and the agent is at an impasse."
+    }
+  },
+  required: ["status"]
+};
+var CREATE_GOAL_EXISTS_MESSAGE = "cannot create a new goal because this thread already has a goal; use update_goal only when the existing goal is complete";
+var UPDATE_GOAL_UNSUPPORTED_STATUS_MESSAGE = "update_goal can only mark the existing goal complete or blocked; pause, resume, budget-limited, and usage-limited status changes are controlled by the user or system";
+async function runGoalAliasTool(toolName, rawParams, defaultScope, reader, workingMemory) {
+  switch (toolName) {
+    case "get_goal":
+      return runGetGoalTool(defaultScope, workingMemory);
+    case "create_goal":
+      return runCreateGoalTool(rawParams, defaultScope, reader, workingMemory);
+    case "update_goal":
+      return runUpdateGoalTool(rawParams, defaultScope, reader, workingMemory);
+  }
+}
+async function runGetGoalTool(defaultScope, workingMemory) {
+  const result = await workingMemory.run({ action: "get", scope: defaultScope });
+  if (!result.ok && result.code === "missing_active_set") {
+    return goalSuccess(null, false);
+  }
+  return resultToGoalOutcome(result, false);
+}
+async function runCreateGoalTool(rawParams, defaultScope, reader, workingMemory) {
+  const params = asRecord(rawParams);
+  const objective = reader.readString(params, "objective", { required: true }) ?? "";
+  const tokenBudget = reader.readNumber(params, "token_budget", { integer: true, strict: true });
+  if (tokenBudget !== void 0 && tokenBudget <= 0) {
+    return goalFailure("invalid_request", "token_budget must be positive.");
+  }
+  const result = await workingMemory.run({
+    action: "create",
+    scope: defaultScope,
+    operation: {
+      type: "set_objective",
+      objective
+    },
+    ...tokenBudget !== void 0 ? { initialBudget: { tokenBudget } } : {},
+    updateReason: "Model created goal via create_goal.",
+    actor: "model",
+    source: "goal_command"
+  });
+  if (!result.ok && result.code === "active_set_exists") {
+    return goalFailure(result.code, CREATE_GOAL_EXISTS_MESSAGE, result.details);
+  }
+  return resultToGoalOutcome(result, false);
+}
+async function runUpdateGoalTool(rawParams, defaultScope, reader, workingMemory) {
+  const params = asRecord(rawParams);
+  const status = reader.readString(params, "status", { required: true });
+  if (!isGoalAliasUpdateStatus(status)) {
+    return goalFailure("invalid_request", UPDATE_GOAL_UNSUPPORTED_STATUS_MESSAGE);
+  }
+  const update = await workingMemory.run({
+    action: "update",
+    scope: defaultScope,
+    operation: {
+      type: "set_status",
+      status
+    },
+    updateReason: status === "complete" ? "Model marked goal complete via update_goal." : "Model marked goal blocked via update_goal.",
+    actor: "model",
+    source: "goal_command"
+  });
+  return resultToGoalOutcome(update, status === "complete");
+}
+function isGoalAliasUpdateStatus(status) {
+  return status === "complete" || status === "blocked";
+}
+function resultToGoalOutcome(result, includeCompletionReport) {
+  if (!result.ok) {
+    return goalFailure(result.code, result.message, result.details);
+  }
+  switch (result.action) {
+    case "get":
+    case "create":
+    case "update":
+      return goalSuccess(result.workingSet, includeCompletionReport);
+    case "list":
+    case "close":
+    case "prepare_external_goal_mutation":
+      return goalFailure("invalid_request", `Goal alias cannot return agenr_work ${result.action} results.`);
+  }
+}
+function goalSuccess(workingSet, includeCompletionReport) {
+  const response = toGoalToolResponse(workingSet, includeCompletionReport);
+  return {
+    text: JSON.stringify(response, null, 2),
+    details: {
+      goal: response.goal,
+      remainingTokens: response.remainingTokens,
+      completionBudgetReport: response.completionBudgetReport
+    },
+    failed: false
+  };
+}
+function goalFailure(code, message, details) {
+  return {
+    text: message,
+    details: {
+      status: "failed",
+      code,
+      ...details ? { details } : {}
+    },
+    failed: true
+  };
+}
+
+// src/adapters/shared/param-readers.ts
+function readStringParam(params, key, options = {}) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    if (options.required) {
+      throw new Error(`${options.label ?? key} is required.`);
+    }
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${options.label ?? key} must be a string.`);
+  }
+  const normalized = options.trim === false ? value : value.trim();
+  if (options.required && normalized.length === 0) {
+    throw new Error(`${options.label ?? key} is required.`);
+  }
+  return normalized.length > 0 || options.trim === false ? normalized : void 0;
+}
+function readNumberParam(params, key, options = {}) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${key} must be a number.`);
+  }
+  if (options.integer && !Number.isInteger(value)) {
+    throw new Error(`${key} must be an integer.`);
+  }
+  if (options.strict && value < 0) {
+    throw new Error(`${key} must be non-negative.`);
+  }
+  return value;
+}
+function readStringArrayParam(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${key} must be an array of strings.`);
+  }
+  return value;
+}
+
+// src/adapters/skeln/tools/shared.ts
+var SKELN_PARAM_READER = {
+  readString: readStringParam,
+  readNumber: readNumberParam,
+  readStringArray: readStringArrayParam
+};
+function toolSchema(value) {
+  return value;
+}
+function textToolResult(text, details) {
+  return {
+    content: [{ type: "text", text }],
+    details
+  };
+}
+function toSkelnToolResult(outcome) {
+  return textToolResult(outcome.text, outcome.details);
+}
+function toolFailureResult(error) {
+  return textToolResult(formatErrorMessage(error), {
+    status: "failed"
+  });
+}
+
+// src/adapters/skeln/tools/goal.ts
+function registerAgenrSkelnGoalAliasTools(skeln, servicesPromise, resolveScope) {
+  registerGoalAliasTool(skeln, servicesPromise, resolveScope, {
+    name: "get_goal",
+    label: "Get Goal",
+    description: "Get the current goal for this thread, including status, budgets, usage, and remaining token budget.",
+    parameters: GET_GOAL_TOOL_PARAMETERS
+  });
+  registerGoalAliasTool(skeln, servicesPromise, resolveScope, {
+    name: "create_goal",
+    label: "Create Goal",
+    description: "Create a goal only when explicitly requested by the user or system/developer instructions. Fails if a goal already exists; use update_goal only for status.",
+    parameters: CREATE_GOAL_TOOL_PARAMETERS
+  });
+  registerGoalAliasTool(skeln, servicesPromise, resolveScope, {
+    name: "update_goal",
+    label: "Update Goal",
+    description: "Update the existing goal. Use this tool only to mark the goal achieved or genuinely blocked; pause, resume, and budget states are controlled by the user or system.",
+    parameters: UPDATE_GOAL_TOOL_PARAMETERS
+  });
+}
+function registerGoalAliasTool(skeln, servicesPromise, resolveScope, definition) {
+  skeln.registerTool({
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    promptSnippet: `${definition.name} is a Codex-compatible alias over Agenr working memory.`,
+    parameters: toolSchema(definition.parameters),
+    execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
+      try {
+        const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+        const outcome = await runGoalAliasTool(definition.name, rawParams, toWorkingScopeFromSkelnSession(scope), SKELN_PARAM_READER, services.workingMemory);
+        return textToolResult(outcome.text, outcome.details);
+      } catch (error) {
+        return toolFailureResult(error);
+      }
+    }
+  });
+}
+
+// src/adapters/skeln/tools/recall.ts
+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.",
+    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."
+    ],
+    parameters: toolSchema(RECALL_TOOL_PARAMETERS),
+    execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
+      try {
+        const params = parseRecallToolParams(rawParams, SKELN_PARAM_READER);
+        const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+        const result = await runRecallMemoryTool(params, buildRecallToolServices(services), {
+          sessionKey: scope.sessionKey,
+          slotPolicyConfig: services.skelnConfig.memoryPolicy?.slotPolicies
+        });
+        return textToolResult(formatUnifiedRecallResults(result), buildRecallToolDetails(result, { sessionKey: scope.sessionKey }));
+      } catch (error) {
+        return toolFailureResult(error);
+      }
+    }
+  });
+}
+
+// src/adapters/skeln/tools/store.ts
+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.",
+    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."
+    ],
+    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}`)
+          })
+        );
+      } catch (error) {
+        return toolFailureResult(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.",
+    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."],
+    parameters: toolSchema(UPDATE_TOOL_PARAMETERS),
+    execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
+      try {
+        const params = parseUpdateToolParams(rawParams, SKELN_PARAM_READER);
+        const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+        const outcome = await runUpdateMemoryTool(params, services, {
+          session: scope,
+          sourcePrefix: "skeln-session",
+          successDetails: { sessionKey: scope.sessionKey },
+          failureDetails: { sessionKey: scope.sessionKey }
+        });
+        return toSkelnToolResult({
+          ...outcome,
+          details: {
+            ...outcome.details,
+            target: formatTargetSelector(params.id, params.subject),
+            sanitized: sanitizeUpdateToolParams({
+              id: params.id,
+              subject: params.subject,
+              importance: params.importance,
+              expiry: params.expiry,
+              claimKey: params.claimKeyInput,
+              validFrom: params.validFrom,
+              validTo: params.validTo
+            })
+          }
+        });
+      } catch (error) {
+        return toolFailureResult(error);
+      }
+    }
+  });
+}
+
+// src/adapters/shared/work-tool-presentations.ts
+function buildWorkingSetGetDetails(workingSet, eventsReturned = 0) {
+  return {
+    status: "ok",
+    action: "get",
+    workingSetId: workingSet.id,
+    revision: workingSet.revision,
+    goalGeneration: readGoalGeneration(workingSet.snapshot),
+    goalStatus: workingSet.status,
+    objective: workingSet.snapshot.objective ?? workingSet.objective ?? null,
+    checkpoint: workingSet.snapshot.checkpoint ?? null,
+    continuation: workingSet.snapshot.continuation ?? null,
+    budgets: workingSet.snapshot.budgets ?? null,
+    eventsReturned
+  };
+}
+function buildWorkingMemoryDetails(result) {
+  if (!result.ok) {
+    return {
+      status: "failed",
+      code: result.code,
+      ...result.details ? { details: result.details } : {}
+    };
+  }
+  switch (result.action) {
+    case "get":
+      return buildWorkingSetGetDetails(result.workingSet, result.events?.length ?? 0);
+    case "list":
+      return {
+        status: "ok",
+        action: "list",
+        count: result.workingSets.length,
+        workingSetIds: result.workingSets.map((set) => set.id)
+      };
+    case "create":
+      return {
+        status: "ok",
+        action: "create",
+        workingSetId: result.workingSet.id,
+        revision: result.workingSet.revision,
+        goalGeneration: readGoalGeneration(result.workingSet.snapshot)
+      };
+    case "update":
+      return {
+        status: "ok",
+        action: "update",
+        workingSetId: result.workingSet.id,
+        revision: result.workingSet.revision,
+        goalGeneration: readGoalGeneration(result.workingSet.snapshot)
+      };
+    case "close":
+      return {
+        status: "ok",
+        action: "close",
+        workingSetId: result.workingSet.id,
+        revision: result.workingSet.revision,
+        goalGeneration: readGoalGeneration(result.workingSet.snapshot),
+        candidateCount: result.candidates.length
+      };
+    case "prepare_external_goal_mutation":
+      return {
+        status: "ok",
+        action: "prepare_external_goal_mutation",
+        prepared: result.prepared,
+        workingSetId: result.workingSet?.id ?? null,
+        revision: result.workingSet?.revision ?? null,
+        eventsReturned: result.events.length
+      };
+  }
+}
+function formatWorkingMemoryResultText(result) {
+  if (!result.ok) {
+    return `agenr_work failed: ${result.message}`;
+  }
+  switch (result.action) {
+    case "get":
+      return result.projection.content;
+    case "list":
+      if (result.workingSets.length === 0) {
+        return "No working sets matched.";
+      }
+      return result.workingSets.map((set) => `${set.id} rev ${set.revision} ${set.status}: ${set.snapshot.objective ?? set.title ?? set.scopeKey}`).join("\n");
+    case "create":
+      return `Created working set ${result.workingSet.id} at revision ${result.workingSet.revision}.`;
+    case "update":
+      return `Updated working set ${result.workingSet.id} at revision ${result.workingSet.revision}.`;
+    case "close":
+      return `Closed working set ${result.workingSet.id} at revision ${result.workingSet.revision}. Candidates: ${result.candidates.length}.`;
+    case "prepare_external_goal_mutation":
+      if (!result.prepared || !result.workingSet) {
+        return "No active working set required external mutation preparation.";
+      }
+      return `Prepared working set ${result.workingSet.id} at revision ${result.workingSet.revision}. Events: ${result.events.length}.`;
+  }
+}
+
+// src/adapters/shared/work-tool-policy.ts
+var MODEL_VISIBLE_WORK_ACTIONS = ["get", "list", "create", "update"];
+var RESERVED_MODEL_WORK_MESSAGES = {
+  close: "agenr_work failed: agenr_work close is reserved for /goal clear and host lifecycle paths.",
+  set_status: "agenr_work failed: status changes are reserved for get_goal/create_goal/update_goal and trusted host lifecycle paths."
+};
+function getModelReservedWorkAction(params) {
+  if (params.source !== void 0 && params.source !== "tool") {
+    return null;
+  }
+  if (params.action === "close") {
+    return "close";
+  }
+  if (params.operation?.type === "set_status") {
+    return "set_status";
+  }
+  return null;
+}
+function isModelVisibleWorkAction(value) {
+  return value !== void 0 && MODEL_VISIBLE_WORK_ACTIONS.includes(value);
+}
+
+// src/adapters/shared/work-tool-operation-parsers.ts
+function optionalStringParam(record, key, reader) {
+  const value = reader.readString(record, key);
+  return value ? { [key]: value } : {};
+}
+function requiredString(record, key, reader) {
+  return reader.readString(record, key, { required: true }) ?? "";
+}
+function requiredStringArray(record, key, reader) {
+  const value = reader.readStringArray(record, key);
+  if (!value) {
+    throw new Error(`${key} is required.`);
+  }
+  return value;
+}
+function requiredNumberArray(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "number" || !Number.isInteger(item))) {
+    throw new Error(`${key} must be an array of integers.`);
+  }
+  return value;
+}
+function requiredBoolean(record, key) {
+  const value = record[key];
+  if (typeof value !== "boolean") {
+    throw new Error(`${key} must be a boolean.`);
+  }
+  return value;
+}
+function parseArray(value, parse, key, reader) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${key} must be an array.`);
+  }
+  return value.map((item) => parse(item, reader));
+}
+function optionalNumberParam(record, key, reader) {
+  const value = reader.readNumber(record, key, { integer: true, strict: true });
+  return value !== void 0 ? { [key]: value } : {};
+}
+function optionalBooleanParam(record, key) {
+  const value = record[key];
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`${key} must be a boolean.`);
+  }
+  return { [key]: value };
+}
+function parseNextActionStatus(value) {
+  if (value === "pending" || value === "in_progress" || value === "blocked" || value === "done") {
+    return value;
+  }
+  throw new Error(`Unsupported next-action status "${value}".`);
+}
+function parseConfidence(value) {
+  if (value === "low" || value === "medium" || value === "high") {
+    return value;
+  }
+  throw new Error(`Unsupported assumption confidence "${value}".`);
+}
+function parsePromotionStatus(value) {
+  if (WORKING_CANDIDATE_PROMOTION_STATUSES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported candidate promotion status "${value}".`);
+}
+function parseNextAction(value, reader) {
+  const record = asRecord(value);
+  const status = reader.readString(record, "status");
+  return {
+    text: requiredString(record, "text", reader),
+    ...status ? { status: parseNextActionStatus(status) } : {},
+    ...optionalStringParam(record, "ref", reader)
+  };
+}
+function parseCheckpoint(value, reader) {
+  const record = asRecord(value);
+  return {
+    summary: requiredString(record, "summary", reader),
+    recordedAt: requiredString(record, "recordedAt", reader),
+    ...record.nextActions !== void 0 ? { nextActions: requiredStringArray(record, "nextActions", reader) } : {},
+    ...record.blockers !== void 0 ? { blockers: requiredStringArray(record, "blockers", reader) } : {}
+  };
+}
+function parseFileNote(value, reader) {
+  const record = asRecord(value);
+  return {
+    path: requiredString(record, "path", reader),
+    ...optionalStringParam(record, "note", reader),
+    ...optionalStringParam(record, "observedAt", reader)
+  };
+}
+function parseCommandNote(value, reader) {
+  const record = asRecord(value);
+  return {
+    command: requiredString(record, "command", reader),
+    ...optionalStringParam(record, "outcome", reader),
+    ...optionalStringParam(record, "observedAt", reader)
+  };
+}
+function parseDecisionNote(value, reader) {
+  const record = asRecord(value);
+  return {
+    decision: requiredString(record, "decision", reader),
+    ...optionalStringParam(record, "rationale", reader),
+    ...optionalStringParam(record, "decidedAt", reader)
+  };
+}
+function parseAssumptionNote(value, reader) {
+  const record = asRecord(value);
+  const confidence = reader.readString(record, "confidence");
+  return {
+    assumption: requiredString(record, "assumption", reader),
+    ...confidence ? { confidence: parseConfidence(confidence) } : {},
+    ...record.validated !== void 0 ? { validated: requiredBoolean(record, "validated") } : {}
+  };
+}
+function parseCandidateProvenance(value, reader) {
+  const record = asRecord(value);
+  return {
+    evidenceEventSequences: requiredNumberArray(record, "evidenceEventSequences"),
+    ...optionalStringParam(record, "sourceRef", reader),
+    ...optionalStringParam(record, "note", reader)
+  };
+}
+function parseCandidate(value, reader) {
+  const record = asRecord(value);
+  const kind = requiredString(record, "kind", reader);
+  const provenance = parseCandidateProvenance(record.provenance, reader);
+  const promotionStatus = parsePromotionStatus(requiredString(record, "promotionStatus", reader));
+  if (kind === "episodic") {
+    return {
+      kind,
+      summary: requiredString(record, "summary", reader),
+      provenance,
+      promotionStatus
+    };
+  }
+  if (kind === "semantic" || kind === "procedural") {
+    return {
+      kind,
+      subject: requiredString(record, "subject", reader),
+      content: requiredString(record, "content", reader),
+      ...optionalStringParam(record, "suggestedClaimKey", reader),
+      provenance,
+      promotionStatus
+    };
+  }
+  throw new Error(`Unsupported working candidate kind "${kind}".`);
+}
+
+// src/adapters/shared/work-tool-operation-schemas.ts
+var NEXT_ACTION_STATUSES = ["pending", "in_progress", "blocked", "done"];
+var ASSUMPTION_CONFIDENCE_VALUES = ["low", "medium", "high"];
+function operationVariant(required, properties) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    required
+  };
+}
+function constString(value) {
+  return { type: "string", const: value };
+}
+function stringArray(description) {
+  return {
+    type: "array",
+    description,
+    items: { type: "string" }
+  };
+}
+function nextActionsSchema() {
+  return {
+    type: "array",
+    items: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        text: { type: "string" },
+        status: { type: "string", enum: [...NEXT_ACTION_STATUSES] },
+        ref: { type: "string" }
+      },
+      required: ["text"]
+    }
+  };
+}
+function checkpointSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      summary: { type: "string", description: "Compact summary of current progress." },
+      recordedAt: { type: "string", description: "ISO timestamp when the checkpoint was recorded." },
+      nextActions: stringArray("Expected next actions after the checkpoint."),
+      blockers: stringArray("Known blockers at checkpoint time.")
+    },
+    required: ["summary", "recordedAt"]
+  };
+}
+function fileNoteSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      path: { type: "string" },
+      note: { type: "string" },
+      observedAt: { type: "string" }
+    },
+    required: ["path"]
+  };
+}
+function commandNoteSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      command: { type: "string" },
+      outcome: { type: "string" },
+      observedAt: { type: "string" }
+    },
+    required: ["command"]
+  };
+}
+function decisionNoteSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      decision: { type: "string" },
+      rationale: { type: "string" },
+      decidedAt: { type: "string" }
+    },
+    required: ["decision"]
+  };
+}
+function assumptionNoteSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      assumption: { type: "string" },
+      confidence: { type: "string", enum: [...ASSUMPTION_CONFIDENCE_VALUES] },
+      validated: { type: "boolean" }
+    },
+    required: ["assumption"]
+  };
+}
+function candidateProvenanceSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      evidenceEventSequences: {
+        type: "array",
+        items: { type: "integer" }
+      },
+      sourceRef: { type: "string" },
+      note: { type: "string" }
+    },
+    required: ["evidenceEventSequences"]
+  };
+}
+function candidatePromotionSchema() {
+  return { type: "string", enum: [...WORKING_CANDIDATE_PROMOTION_STATUSES] };
+}
+function candidateSchema() {
+  return {
+    oneOf: [
+      operationVariant(["kind", "summary", "provenance", "promotionStatus"], {
+        kind: constString("episodic"),
+        summary: { type: "string" },
+        provenance: candidateProvenanceSchema(),
+        promotionStatus: candidatePromotionSchema()
+      }),
+      operationVariant(["kind", "subject", "content", "provenance", "promotionStatus"], {
+        kind: constString("semantic"),
+        subject: { type: "string" },
+        content: { type: "string" },
+        suggestedClaimKey: { type: "string" },
+        provenance: candidateProvenanceSchema(),
+        promotionStatus: candidatePromotionSchema()
+      }),
+      operationVariant(["kind", "subject", "content", "provenance", "promotionStatus"], {
+        kind: constString("procedural"),
+        subject: { type: "string" },
+        content: { type: "string" },
+        suggestedClaimKey: { type: "string" },
+        provenance: candidateProvenanceSchema(),
+        promotionStatus: candidatePromotionSchema()
+      })
+    ]
+  };
+}
+function createOperationSchema(schemas) {
+  return {
+    description: "Typed working-memory operation for create and update. Always include operation.type and the required payload field for that variant.",
+    oneOf: schemas
+  };
+}
+
+// src/adapters/shared/work-tool-operation-registry.ts
+var MODEL_VISIBLE_OPERATIONS = {
+  set_objective: {
+    buildSchema: () => operationVariant(["type", "objective"], {
+      type: constString("set_objective"),
+      objective: { type: "string", description: "Current concrete objective." },
+      title: { type: "string", description: "Optional display title." }
+    }),
+    parse: (record, reader) => ({
+      type: "set_objective",
+      objective: requiredString(record, "objective", reader),
+      ...optionalStringParam(record, "title", reader)
+    })
+  },
+  replace_plan: {
+    buildSchema: () => operationVariant(["type", "currentPlan"], {
+      type: constString("replace_plan"),
+      currentPlan: stringArray("Ordered current plan steps."),
+      nextActions: nextActionsSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "replace_plan",
+      currentPlan: requiredStringArray(record, "currentPlan", reader),
+      ...record.nextActions !== void 0 ? { nextActions: parseArray(record.nextActions, parseNextAction, "nextActions", reader) } : {}
+    })
+  },
+  merge_checkpoint: {
+    buildSchema: () => operationVariant(["type", "checkpoint"], {
+      type: constString("merge_checkpoint"),
+      checkpoint: checkpointSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "merge_checkpoint",
+      checkpoint: parseCheckpoint(record.checkpoint, reader)
+    })
+  },
+  add_file_note: {
+    buildSchema: () => operationVariant(["type", "file"], {
+      type: constString("add_file_note"),
+      file: fileNoteSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "add_file_note",
+      file: parseFileNote(record.file, reader)
+    })
+  },
+  add_command_note: {
+    buildSchema: () => operationVariant(["type", "command"], {
+      type: constString("add_command_note"),
+      command: commandNoteSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "add_command_note",
+      command: parseCommandNote(record.command, reader)
+    })
+  },
+  record_decision: {
+    buildSchema: () => operationVariant(["type", "decision"], {
+      type: constString("record_decision"),
+      decision: decisionNoteSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "record_decision",
+      decision: parseDecisionNote(record.decision, reader)
+    })
+  },
+  record_assumption: {
+    buildSchema: () => operationVariant(["type", "assumption"], {
+      type: constString("record_assumption"),
+      assumption: assumptionNoteSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "record_assumption",
+      assumption: parseAssumptionNote(record.assumption, reader)
+    })
+  },
+  set_next_actions: {
+    buildSchema: () => operationVariant(["type", "nextActions"], {
+      type: constString("set_next_actions"),
+      nextActions: nextActionsSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "set_next_actions",
+      nextActions: parseArray(record.nextActions, parseNextAction, "nextActions", reader)
+    })
+  },
+  add_candidate: {
+    buildSchema: () => operationVariant(["type", "candidate"], {
+      type: constString("add_candidate"),
+      candidate: candidateSchema()
+    }),
+    parse: (record, reader) => ({
+      type: "add_candidate",
+      candidate: parseCandidate(record.candidate, reader)
+    })
+  }
+};
+var MODEL_VISIBLE_OPERATION_SCHEMAS = Object.keys(MODEL_VISIBLE_OPERATIONS).map(
+  (operationType) => MODEL_VISIBLE_OPERATIONS[operationType].buildSchema()
+);
+
+// src/adapters/shared/work-tool-operations.ts
+var WORK_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    action: {
+      type: "string",
+      enum: [...MODEL_VISIBLE_WORK_ACTIONS],
+      description: "Working-memory action to run. Close is reserved for /goal clear and host lifecycle paths."
+    },
+    workingSetId: {
+      type: "string",
+      description: "Explicit working-set id when known."
+    },
+    scope: {
+      type: "object",
+      description: "Working-memory scope facts. Session-scoped goals require conversationKey (or taskId / gitRoot+gitBranch / gitRoot+cwd). sessionKey and scopeKey are not accepted.",
+      additionalProperties: false,
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Host session id stored as provenance; does not select scope by itself."
+        },
+        conversationKey: {
+          type: "string",
+          description: "Primary session/thread identity for goal binding (preferred for Skeln sessions)."
+        },
+        gitRoot: { type: "string" },
+        gitBranch: { type: "string" },
+        cwd: { type: "string" },
+        project: { type: "string" },
+        taskId: { type: "string" }
+      }
+    },
+    operation: createOperationSchema(MODEL_VISIBLE_OPERATION_SCHEMAS),
+    expectedRevision: {
+      type: "integer",
+      minimum: 0,
+      description: "Required for update. Revision observed before update."
+    },
+    updateReason: {
+      type: "string",
+      description: "Human-readable audit reason for create or update."
+    },
+    includeEvents: {
+      type: "boolean",
+      description: "Include recent events in get output."
+    },
+    eventLimit: {
+      type: "integer",
+      minimum: 1,
+      maximum: 200,
+      description: "Maximum events for get output."
+    },
+    listLimit: {
+      type: "integer",
+      minimum: 1,
+      maximum: 100,
+      description: "Maximum working sets for list output."
+    }
+  },
+  required: ["action"]
+};
+function parseWorkToolParams(rawParams, defaultScope, reader) {
+  const params = asRecord(rawParams);
+  const action = parseAction(reader.readString(params, "action", { required: true }));
+  return {
+    action,
+    ...optionalStringParam(params, "workingSetId", reader),
+    scope: mergeWorkingScope(defaultScope, parseScope(params.scope, reader)),
+    ...params.operation !== void 0 ? { operation: parseOperation(params.operation, reader) } : {},
+    ...optionalNumberParam(params, "expectedRevision", reader),
+    ...optionalStringParam(params, "updateReason", reader),
+    ...optionalBooleanParam(params, "includeEvents"),
+    ...optionalNumberParam(params, "eventLimit", reader),
+    ...optionalNumberParam(params, "listLimit", reader),
+    actor: "model",
+    source: "tool"
+  };
+}
+function mergeWorkingScope(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function parseAction(value) {
+  if (isModelVisibleWorkAction(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported agenr_work action "${value ?? ""}".`);
+}
+function parseScope(value, reader) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  const record = asRecord(value);
+  return {
+    ...optionalStringParam(record, "sessionId", reader),
+    ...optionalStringParam(record, "gitRoot", reader),
+    ...optionalStringParam(record, "gitBranch", reader),
+    ...optionalStringParam(record, "cwd", reader),
+    ...optionalStringParam(record, "project", reader),
+    ...optionalStringParam(record, "taskId", reader),
+    ...optionalStringParam(record, "conversationKey", reader)
+  };
+}
+function parseOperation(value, reader) {
+  const record = asRecord(value);
+  const type = reader.readString(record, "type", { required: true });
+  if (type && isModelVisibleOperationType(type)) {
+    return MODEL_VISIBLE_OPERATIONS[type].parse(record, reader);
+  }
+  throw new Error(`Unsupported agenr_work operation "${type ?? ""}".`);
+}
+
+// src/adapters/shared/work-tools.ts
+async function runWorkMemoryTool(params, workingMemory) {
+  const reserved = getModelReservedWorkAction(params);
+  if (reserved) {
+    return {
+      text: RESERVED_MODEL_WORK_MESSAGES[reserved],
+      details: {
+        status: "failed",
+        code: reserved === "close" ? "reserved_close" : "reserved_status"
+      },
+      failed: true
+    };
+  }
+  const result = await workingMemory.run(params);
+  return workingMemoryResultToToolOutcome(result);
+}
+function workingMemoryResultToToolOutcome(result) {
+  return {
+    text: formatWorkingMemoryResultText(result),
+    details: buildWorkingMemoryDetails(result),
+    failed: !result.ok
+  };
+}
+
+// src/adapters/skeln/tools/work.ts
+function registerAgenrSkelnWorkTool(skeln, servicesPromise, resolveScope) {
+  skeln.registerTool({
+    name: "agenr_work",
+    label: "Agenr Work",
+    description: "Read or update transient working memory for the active task. Use this for task state, checkpoints, next actions, files, commands, blockers, and close handoff candidates, not durable facts.",
+    promptSnippet: "Use agenr_work to keep active task state current without storing transient work in durable memory.",
+    promptGuidelines: [
+      "Use create with set_objective to start a new scoped working set only when no goal exists for the scope, including completed goals awaiting user clear.",
+      "Use update only for material task-state changes, and always pass expectedRevision plus updateReason.",
+      "Use merge_checkpoint before pausing, compacting, handing off, forking, or waiting.",
+      "Do not call close; only the user clears goals with /goal clear.",
+      "After delivering results, leave the working set open and record progress with merge_checkpoint.",
+      "Do not use agenr_store for transient WIP."
+    ],
+    parameters: toolSchema(WORK_TOOL_PARAMETERS),
+    execute: async (_toolCallId, rawParams, _signal, _onUpdate, context) => {
+      try {
+        const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+        const params = parseWorkToolParams(rawParams, toWorkingScopeFromSkelnSession(scope), SKELN_PARAM_READER);
+        const outcome = await runWorkMemoryTool(params, services.workingMemory);
+        return textToolResult(outcome.text, outcome.details);
+      } catch (error) {
+        return toolFailureResult(error);
+      }
+    }
+  });
+}
+
+// src/adapters/skeln/tools/index.ts
+function registerAgenrSkelnTools(skeln, servicesPromise, resolveScope) {
+  registerAgenrSkelnStoreTool(skeln, servicesPromise, resolveScope);
+  registerAgenrSkelnRecallTool(skeln, servicesPromise, resolveScope);
+  registerAgenrSkelnUpdateTool(skeln, servicesPromise, resolveScope);
+  registerAgenrSkelnWorkTool(skeln, servicesPromise, resolveScope);
+  registerAgenrSkelnGoalAliasTools(skeln, servicesPromise, resolveScope);
+}
+
+// src/adapters/skeln/episode/goal-close-episode.ts
+var SKELN_GOAL_CLOSE_EPISODE_GENERATOR_VERSION = "skeln-goal-close-episodic-v1";
+var SKELN_GOAL_CLOSE_EPISODE_ACTIVITY_THRESHOLD = {
+  minMaterialTurns: 2,
+  minDurationMs: 0
+};
+function scheduleSkelnGoalCloseEpisodePromotion(params) {
+  const pendingEpisodic = params.closeResult.candidates.some((candidate) => candidate.kind === "episodic" && candidate.promotionStatus === "pending");
+  if (!pendingEpisodic) {
+    return;
+  }
+  void writeSkelnGoalCloseEpisode({
+    context: params.context,
+    services: params.services,
+    workingSetId: params.closeResult.workingSet.id,
+    logger: params.logger
+  }).catch((error) => {
+    const logger = params.logger ?? console;
+    logger.warn(`[agenr] skeln goal close episode promotion failed: ${error instanceof Error ? error.message : String(error)}`);
+  });
+}
+async function writeSkelnGoalCloseEpisode(params) {
+  const sessionId = String(params.context.sessionManager.getSessionId());
+  await writeSkelnBoundedSessionEpisode({
+    context: params.context,
+    services: params.services,
+    logger: params.logger,
+    actionLabel: "skeln goal close episode promotion",
+    genVersion: SKELN_GOAL_CLOSE_EPISODE_GENERATOR_VERSION,
+    activityThreshold: SKELN_GOAL_CLOSE_EPISODE_ACTIVITY_THRESHOLD,
+    buildSourceRef: (sessionFile) => `${sessionFile}#working_set:${params.workingSetId}`,
+    logContext: `session=${sessionId} workingSet=${params.workingSetId}`,
+    skipDetails: `session=${sessionId} workingSet=${params.workingSetId}`
+  });
+}
+
+// src/adapters/skeln/work-command.ts
+async function executeAgenrSkelnWorkCommand(servicesPromise, resolveScope, context, params) {
+  const [services, scope] = await Promise.all([servicesPromise, resolveScope(context)]);
+  const workingScope = {
+    ...toWorkingScopeFromSkelnSession(scope),
+    ...params.scope ?? {}
+  };
+  const result = params.action === "prepare_external_goal_mutation" ? await services.workingMemory.prepareExternalGoalMutation({
+    ...params,
+    scope: workingScope
+  }) : await services.workingMemory.run({
+    ...toAgenrWorkParams(params),
+    scope: workingScope
+  });
+  if (!result.ok) {
+    return workingMemoryResultToToolOutcome(result);
+  }
+  if (params.action === "close" && params.createEpisode && result.action === "close") {
+    scheduleSkelnGoalCloseEpisodePromotion({
+      context,
+      services,
+      closeResult: result
+    });
+  }
+  return workingMemoryResultToToolOutcome(result);
+}
+function toAgenrWorkParams(params) {
+  switch (params.action) {
+    case "get":
+      return {
+        action: "get",
+        ...params.workingSetId !== void 0 ? { workingSetId: params.workingSetId } : {},
+        ...params.includeEvents !== void 0 ? { includeEvents: params.includeEvents } : {},
+        ...params.eventLimit !== void 0 ? { eventLimit: params.eventLimit } : {}
+      };
+    case "list":
+      return {
+        action: "list",
+        ...params.listLimit !== void 0 ? { listLimit: params.listLimit } : {}
+      };
+    case "create":
+      return {
+        action: "create",
+        operation: params.operation,
+        updateReason: params.updateReason,
+        source: params.source,
+        ...params.actor !== void 0 ? { actor: params.actor } : {},
+        ...params.initialBudget !== void 0 ? { initialBudget: params.initialBudget } : {},
+        ...params.continuationPolicy !== void 0 ? { continuationPolicy: params.continuationPolicy } : {}
+      };
+    case "update":
+      return {
+        action: "update",
+        operation: params.operation,
+        updateReason: params.updateReason,
+        source: params.source,
+        ...params.expectedRevision !== void 0 ? { expectedRevision: params.expectedRevision } : {},
+        ...params.workingSetId !== void 0 ? { workingSetId: params.workingSetId } : {},
+        ...params.actor !== void 0 ? { actor: params.actor } : {}
+      };
+    case "close":
+      return {
+        action: "close",
+        closeReason: params.closeReason,
+        source: params.source,
+        ...params.expectedRevision !== void 0 ? { expectedRevision: params.expectedRevision } : {},
+        ...params.workingSetId !== void 0 ? { workingSetId: params.workingSetId } : {},
+        ...params.actor !== void 0 ? { actor: params.actor } : {},
+        ...params.closeMode !== void 0 ? { closeMode: params.closeMode } : {},
+        ...params.createEpisode !== void 0 ? { createEpisode: params.createEpisode } : {}
+      };
+    case "prepare_external_goal_mutation":
+      throw new Error("prepare_external_goal_mutation must be executed through prepareExternalGoalMutation.");
+  }
+}
+
+// src/adapters/skeln/index.ts
+function registerAgenrSkelnMemory(skeln, options = {}) {
+  const memoryPolicySetting = readSkelnMemoryPolicySetting(skeln);
+  if (!memoryPolicySetting.ok) {
+    console.warn(`[agenr] invalid memoryPolicy setting: ${memoryPolicySetting.error}`);
+  }
+  const config = {
+    dbPath: options.dbPath ?? readStringSetting(skeln, "dbPath"),
+    configPath: options.configPath ?? readStringSetting(skeln, "configPath"),
+    memoryPolicy: mergeSkelnMemoryPolicy(memoryPolicySetting.ok ? memoryPolicySetting.value : void 0, options.memoryPolicy),
+    ...options.featureFlags ? { featureFlags: options.featureFlags } : {}
+  };
+  const servicesPromise = createAgenrSkelnServices(config);
+  const scopeTracker = createSkelnSessionScopeTracker();
+  const sessionStartTracker = createSessionStartTracker();
+  const lifecycle = skeln;
+  const resolveScope = async (context) => resolveCurrentSkelnSessionScope(context, scopeTracker, options);
+  void servicesPromise.catch((error) => {
+    console.error(`[agenr] startup failed: ${formatErrorMessage(error)}`);
+  });
+  registerAgenrSkelnTools(skeln, servicesPromise, resolveScope);
+  registerAgenrSkelnFailureBoundary(lifecycle);
+  registerAgenrSkelnInjectionHooks(lifecycle, scopeTracker, servicesPromise, sessionStartTracker, resolveScope);
+  registerAgenrSkelnSessionMemoryHooks(lifecycle, scopeTracker, servicesPromise, resolveScope);
+  registerAgenrSkelnSubagentFindingHooks(lifecycle, servicesPromise, resolveScope);
+  return {
+    executeWorkCommand: (context, params) => executeAgenrSkelnWorkCommand(servicesPromise, resolveScope, context, params)
+  };
+}
+function extension(skeln) {
+  registerAgenrSkelnMemory(skeln);
+}
+function registerAgenrSkelnInjectionHooks(skeln, scopeTracker, servicesPromise, sessionStartTracker, 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)));
+    } catch (error) {
+      console.warn(`[agenr] session_start scope failed: ${formatErrorMessage(error)}`);
+    }
+  });
+  skeln.on(
+    "before_agent_start",
+    async (event, context) => handleAgenrSkelnBeforeAgentStart(event, context, {
+      servicesPromise,
+      sessionStartTracker,
+      resolveScope
+    })
+  );
+}
+function registerAgenrSkelnSessionMemoryHooks(skeln, scopeTracker, servicesPromise, resolveScope) {
+  skeln.on("session_before_fork", async (event, context) => {
+    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeForkTriggerEvent(scope, event));
+  });
+  skeln.on("session_before_compact", async (_event, context) => {
+    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeCompactTriggerEvent(scope));
+  });
+  skeln.on("session_compact", async (event, context) => {
+    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionCompactTriggerEvent(scope, event));
+  });
+  skeln.on("session_before_tree", async (event, context) => {
+    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionBeforeTreeTriggerEvent(scope, event));
+  });
+  skeln.on("session_tree", async (event, context) => {
+    await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionTreeTriggerEvent(scope, event));
+  });
+  skeln.on("session_shutdown", async (event, context) => {
+    await handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context);
+  });
+}
+async function handleSkelnSessionShutdown(servicesPromise, scopeTracker, resolveScope, event, context) {
+  await routeScopedSessionMemoryTrigger(servicesPromise, resolveScope, context, (scope) => buildSkelnSessionShutdownTriggerEvent(scope, event));
+  await writeScopedSkelnShutdownEpisode(servicesPromise, context);
+  clearTrackedSkelnScope(scopeTracker, context);
+  if (event.reason !== "quit") {
+    return;
+  }
+  try {
+    const services = await servicesPromise;
+    await services.close();
+  } catch {
+  }
+}
+function registerAgenrSkelnSubagentFindingHooks(skeln, servicesPromise, resolveScope) {
+  skeln.on("tool_result", async (event, context) => {
+    await recordSkelnSubagentFindings(servicesPromise, resolveScope, context, event);
+    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 writeScopedSkelnShutdownEpisode(servicesPromise, context) {
+  try {
+    const services = await servicesPromise;
+    if (!services.capabilities.shutdownEpisodes) {
+      return;
+    }
+    await writeSkelnShutdownEpisode({ context, services });
+  } catch (error) {
+    console.warn(`[agenr] skeln shutdown episode failed: ${formatErrorMessage(error)}`);
+  }
+}
+async function resolveCurrentSkelnSessionScope(context, scopeTracker, options) {
+  const sessionId = String(context.sessionManager.getSessionId());
+  const tracked = scopeTracker.getSessionScope(sessionId);
+  const defaults = tracked ? {
+    cwd: tracked.cwd,
+    sessionKey: tracked.sessionKey,
+    ...tracked.gitRoot ? { gitRoot: tracked.gitRoot } : {},
+    ...tracked.gitBranch ? { gitBranch: tracked.gitBranch } : {},
+    ...tracked.project ? { project: tracked.project } : {},
+    ...tracked.conversationKey ? { conversationKey: tracked.conversationKey } : {}
+  } : buildSkelnHostContext({
+    sessionId,
+    cwd: resolveContextCwd(context)
+  });
+  const override = options.getHostContext ? await options.getHostContext(context) : void 0;
+  return toSkelnSessionScope(mergeSkelnHostContext(defaults, override), sessionId);
+}
+function rememberSkelnSessionStart(scopeTracker, sessionStartTracker, scope, previousSessionFile) {
+  scopeTracker.rememberSessionStart(scope);
+  sessionStartTracker.rememberSessionStart(scope.sessionId, scope.sessionKey, previousSessionFile);
+}
+function resolveContextCwd(context) {
+  return context.cwd || context.sessionManager.getCwd();
+}
+function clearTrackedSkelnScope(scopeTracker, context) {
+  try {
+    const sessionId = String(context.sessionManager.getSessionId());
+    scopeTracker.clear(sessionId);
+  } catch {
+  }
+}
+function readStringSetting(skeln, key) {
+  const value = skeln.getSetting(key);
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function registerAgenrSkelnFailureBoundary(skeln) {
+  skeln.on("tool_result", (event) => {
+    if (event.isError || !isAgenrToolName(event.toolName) || !isFailedAgenrToolDetails(event.details)) {
+      return void 0;
+    }
+    return { isError: true };
+  });
+}
+function isAgenrToolName(toolName) {
+  return toolName === "agenr_store" || toolName === "agenr_recall" || toolName === "agenr_update" || toolName === "agenr_work" || toolName === "get_goal" || toolName === "create_goal" || toolName === "update_goal";
+}
+function isFailedAgenrToolDetails(details) {
+  return typeof details === "object" && details !== null && "status" in details && details.status === "failed";
+}
+export {
+  createAgenrSkelnServices,
+  extension as default,
+  handleAgenrSkelnBeforeAgentStart,
+  registerAgenrSkelnMemory
+};