omp-fabric 0.85.0

package/dist/chunks/chunk-T6OAX4FO.js

@@ -0,0 +1,1835 @@
+import {
+  DEFAULT_HOT_SESSIONS,
+  DEFAULT_REGEX_MAX_HAYSTACK_BYTES,
+  DEFAULT_REGEX_MAX_HAYSTACK_TERMS,
+  DEFAULT_REGEX_MAX_PATTERN_BYTES,
+  DEFAULT_REGEX_TIMEOUT_MS,
+  fingerprintSource,
+  loadTieredIndex,
+  reconstructSessionLineage,
+  searchMemoryIndex
+} from "./chunk-2KEWFW56.js";
+import {
+  compareLexical,
+  normalizeMemoryPhrase,
+  tokenizeLexical
+} from "./chunk-U5FYOMG5.js";
+import {
+  AmbiguousSessionError,
+  enumerateAllSessions,
+  resolveScope,
+  resolveSessionTarget
+} from "./chunk-7BIA5BJN.js";
+import {
+  expandSessionEntriesChecked,
+  normalizeSession
+} from "./chunk-6QBPSZJ5.js";
+
+// src/providers/memory-provider.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// src/memory/context.ts
+var RECALL_DEFAULT_PAGE_SIZE = 10;
+var RECALL_MAX_PAGE_SIZE = 50;
+var RECALL_DEFAULT_SNIPPET_CHARS = 480;
+var RECALL_MAX_SNIPPET_CHARS = 2e3;
+var RECALL_MAX_RESPONSE_CHARS = 3e4;
+var boundedMetadata = (value, max = 512) => {
+  if (value === void 0 || value === null) return null;
+  return value.length <= max ? value : `${value.slice(0, Math.max(1, max - 1))}\u2026`;
+};
+var safeSlice = (text, start, end) => {
+  let safeStart = Math.max(0, start);
+  let safeEnd = Math.min(text.length, end);
+  const startCode = text.charCodeAt(safeStart);
+  if (safeStart > 0 && startCode >= 56320 && startCode <= 57343) safeStart += 1;
+  const endCode = text.charCodeAt(safeEnd - 1);
+  if (safeEnd < text.length && endCode >= 55296 && endCode <= 56319) safeEnd -= 1;
+  return text.slice(safeStart, safeEnd);
+};
+var snippetAnchor = (text, query, queryMode) => {
+  if (!query) return 0;
+  const normalized = normalizeMemoryPhrase(text);
+  if (queryMode === "phrase") {
+    const phrase = normalizeMemoryPhrase(query.trim());
+    return Math.max(0, normalized.indexOf(phrase));
+  }
+  if (queryMode === "literal") {
+    const terms = [...new Set(tokenizeLexical(query))].sort(
+      (left, right) => right.length - left.length || left.localeCompare(right)
+    );
+    for (const term of terms) {
+      const index = normalized.indexOf(term);
+      if (index >= 0) return index;
+    }
+  }
+  return 0;
+};
+var makeSnippet = (text, query, queryMode, maxChars) => {
+  if (text.length <= maxChars) return { text, truncated: false };
+  const anchor = snippetAnchor(text, query, queryMode);
+  const leadingContext = Math.floor(maxChars / 3);
+  let start = Math.max(0, anchor - leadingContext);
+  let end = Math.min(text.length, start + maxChars);
+  if (end - start < maxChars) start = Math.max(0, end - maxChars);
+  const body = safeSlice(text, start, end);
+  return {
+    text: `${start > 0 ? "\u2026" : ""}${body}${end < text.length ? "\u2026" : ""}`,
+    truncated: true
+  };
+};
+var sourceFromSegment = (segment) => ({
+  sessionId: boundedMetadata(segment.sessionId) ?? "",
+  sessionFile: segment.sessionFile,
+  sourceHash: segment.sourceHash,
+  branches: segment.branches,
+  lineageFingerprint: segment.lineageFingerprint,
+  tier: segment.tier
+});
+var sourceFromDigest = (digest) => ({
+  sessionId: boundedMetadata(digest.sessionId) ?? "",
+  sessionFile: digest.sessionFile,
+  sourceHash: digest.sourceHash,
+  branches: digest.branches,
+  lineageFingerprint: digest.lineageFingerprint,
+  tier: "cold"
+});
+var expandArgs = (source, entry) => ({
+  session: source.sessionFile,
+  expectedSourceHash: source.sourceHash,
+  expectedLineageFingerprint: source.lineageFingerprint,
+  branches: source.branches,
+  indices: [entry.index]
+});
+var entryHit = (segment, item, query, queryMode, snippetChars) => {
+  const entry = item.entry;
+  const source = sourceFromSegment(segment);
+  const snippet = makeSnippet(entry.text, query, queryMode, snippetChars);
+  return {
+    kind: "entry",
+    sessionId: source.sessionId,
+    tier: source.tier,
+    index: entry.index,
+    entryId: boundedMetadata(entry.entryId),
+    parentId: boundedMetadata(entry.parentId),
+    operationAddress: boundedMetadata(entry.operationAddress),
+    type: boundedMetadata(entry.type) ?? "entry",
+    role: boundedMetadata(entry.role),
+    tool: boundedMetadata(entry.toolName),
+    ref: boundedMetadata(entry.ref),
+    provider: boundedMetadata(entry.provider),
+    action: boundedMetadata(entry.action),
+    timestamp: entry.timestamp,
+    isError: entry.isError,
+    ...entry.outcome ? { outcome: entry.outcome } : {},
+    score: item.score,
+    snippet: snippet.text,
+    truncated: snippet.truncated || entry.truncated,
+    follow: { ref: "memory.expand", args: expandArgs(source, entry) }
+  };
+};
+var hydrationArgs = (digest, request) => {
+  const { offset: _offset, entryRange: _entryRange, ...base } = request;
+  return {
+    ...base,
+    scope: `session:${digest.sessionFile}`,
+    branches: digest.branches,
+    expectedSourceHash: digest.sourceHash,
+    expectedLineageFingerprint: digest.lineageFingerprint
+  };
+};
+var sessionHit = (digest, request) => {
+  const source = sourceFromDigest(digest);
+  return {
+    kind: "session",
+    sessionId: source.sessionId,
+    tier: "cold",
+    cwd: boundedMetadata(digest.cwd, 2048) ?? "",
+    lastTimestamp: digest.lastTs,
+    score: digest.score,
+    matchedTerms: digest.matchedTerms,
+    matchedStructuralEntries: digest.matchedStructuralEntries,
+    follow: { ref: "memory.recall", args: hydrationArgs(digest, request) }
+  };
+};
+var recallCandidateCache = /* @__PURE__ */ new WeakMap();
+var flattenCandidates = (result) => {
+  const cached = recallCandidateCache.get(result);
+  if (cached) return cached;
+  const candidates = [];
+  for (const item of result.items) {
+    if (item.kind === "digest") {
+      candidates.push({ kind: "session", digest: item.digest });
+      continue;
+    }
+    for (const entry of item.segment.entries) {
+      if (entry.matched) candidates.push({ kind: "entry", segment: item.segment, item: entry });
+    }
+  }
+  candidates.sort((left, right) => {
+    const leftScore = left.kind === "entry" ? left.item.score : left.digest.score;
+    const rightScore = right.kind === "entry" ? right.item.score : right.digest.score;
+    if (rightScore !== leftScore) return rightScore - leftScore;
+    const leftMtime = left.kind === "entry" ? left.segment.sessionMtime : left.digest.sessionMtime;
+    const rightMtime = right.kind === "entry" ? right.segment.sessionMtime : right.digest.sessionMtime;
+    if (rightMtime !== leftMtime) return rightMtime - leftMtime;
+    if (left.kind !== right.kind) return left.kind === "entry" ? -1 : 1;
+    if (left.kind === "entry" && right.kind === "entry") {
+      if (left.item.entry.index !== right.item.entry.index) {
+        return left.item.entry.index - right.item.entry.index;
+      }
+      return compareLexical(left.segment.sessionFile, right.segment.sessionFile);
+    }
+    if (left.kind === "session" && right.kind === "session") {
+      return compareLexical(left.digest.sessionFile, right.digest.sessionFile);
+    }
+    return 0;
+  });
+  recallCandidateCache.set(result, candidates);
+  return candidates;
+};
+var materializeCandidate = (candidate, query, queryMode, snippetChars, request) => candidate.kind === "session" ? sessionHit(candidate.digest, request) : entryHit(candidate.segment, candidate.item, query, queryMode, snippetChars);
+var canonicalNextArgs = (request, offset) => {
+  const { offset: _offset, ...base } = request;
+  return { ...base, offset };
+};
+var presentRecall = (input) => {
+  const candidates = flattenCandidates(input.result);
+  const start = input.offset ?? 0;
+  let selected = candidates.slice(start, start + input.pageSize);
+  const build = (pageCandidates) => {
+    const hits = pageCandidates.map(
+      (candidate) => materializeCandidate(
+        candidate,
+        input.query,
+        input.queryMode,
+        input.snippetChars,
+        input.requestArgs
+      )
+    );
+    return {
+      total: candidates.length,
+      hits,
+      next: start + hits.length < candidates.length ? { ref: "memory.recall", args: canonicalNextArgs(input.requestArgs, start + hits.length) } : null,
+      coverage: input.coverage
+    };
+  };
+  let response = build(selected);
+  while (selected.length > 1 && JSON.stringify(response).length > RECALL_MAX_RESPONSE_CHARS) {
+    selected = selected.slice(0, -1);
+    response = build(selected);
+  }
+  return response;
+};
+
+// src/providers/arg-normalization.ts
+var normalizeForm = (key) => key.toLowerCase().replace(/[^a-z0-9]/g, "");
+var KEY_SYNONYM_CLASSES = [
+  ["session", "sessionId", "id", "file", "path"],
+  ["hypothesisId", "id"],
+  ["id", "agentId", "actorId", "runId"],
+  ["query", "q"],
+  ["limit", "max", "pageSize"],
+  ["task", "prompt", "instructions"],
+  ["label", "labels", "name", "title"],
+  ["summary", "description"],
+  ["text", "message", "body"],
+  ["check", "command", "cmd", "script", "predicate"],
+  ["files", "paths"],
+  ["ifVersion", "versionRef", "version"],
+  ["indices", "index"]
+];
+var KEY_CLASS_FORMS = KEY_SYNONYM_CLASSES.map(
+  (cls) => new Set(cls.map(normalizeForm))
+);
+var ENUM_VALUE_CLASSES = [
+  ["project", "cwd", "repo", "repository", "workspace", "checkout", "tree"],
+  ["global", "all"],
+  ["permanent", "pinned", "sticky", "durable"]
+];
+var VALUE_CLASS_FORMS = ENUM_VALUE_CLASSES.map(
+  (cls) => new Set(cls.map(normalizeForm))
+);
+var numericKind = (property) => {
+  if (!property || typeof property !== "object") return void 0;
+  const schema = property;
+  if (schema.type === "number" || schema.type === "integer") return "scalar";
+  if (schema.type === "array") {
+    const items = schema.items;
+    if (items && typeof items === "object" && (items.type === "number" || items.type === "integer")) {
+      return "array";
+    }
+  }
+  return void 0;
+};
+var stringEnumValues = (property) => {
+  if (!property || typeof property !== "object") return void 0;
+  const schema = property;
+  if (Array.isArray(schema.enum)) {
+    const values = schema.enum.filter(
+      (entry) => typeof entry === "string"
+    );
+    return values.length > 0 ? values : void 0;
+  }
+  for (const branch of [schema.oneOf, schema.anyOf]) {
+    if (!Array.isArray(branch)) continue;
+    const consts = branch.map(
+      (entry) => entry && typeof entry === "object" ? entry.const : void 0
+    ).filter((entry) => typeof entry === "string");
+    if (consts.length > 0) return consts;
+  }
+  return void 0;
+};
+var deriveEnumValueMap = (values) => {
+  const map = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const form = normalizeForm(value);
+    seen.set(form, seen.has(form) ? void 0 : value);
+  }
+  for (const [form, value] of seen) if (value !== void 0) map.set(form, value);
+  for (const classForms of VALUE_CLASS_FORMS) {
+    const members = values.filter((value) => classForms.has(normalizeForm(value)));
+    if (members.length !== 1) continue;
+    const [hit] = members;
+    for (const form of classForms) {
+      if (form !== normalizeForm(hit) && !map.has(form)) map.set(form, hit);
+    }
+  }
+  return map;
+};
+var deriveAction = (inputSchema, explicit) => {
+  const properties = inputSchema && typeof inputSchema === "object" && inputSchema.properties && typeof inputSchema.properties === "object" ? inputSchema.properties : void 0;
+  const declared = new Set(Object.keys(properties ?? {}));
+  const declaredForms = /* @__PURE__ */ new Map();
+  const ambiguousForms = /* @__PURE__ */ new Set();
+  for (const key of declared) {
+    const form = normalizeForm(key);
+    if (declaredForms.has(form)) {
+      ambiguousForms.add(form);
+      declaredForms.delete(form);
+    } else if (!ambiguousForms.has(form)) {
+      declaredForms.set(form, key);
+    }
+  }
+  const singulars = /* @__PURE__ */ new Map();
+  for (const key of declared) {
+    const form = normalizeForm(key);
+    if (!form.endsWith("s")) continue;
+    const singular = form.slice(0, -1);
+    if (!singular || declaredForms.has(singular) || singular === form) continue;
+    if (singulars.get(singular) !== void 0) singulars.delete(singular);
+    else singulars.set(singular, key);
+  }
+  for (const form of ambiguousForms) singulars.delete(form);
+  const numerics = new Set(explicit?.numerics ?? []);
+  const numericArrays = new Set(explicit?.numericArrays ?? []);
+  const values = /* @__PURE__ */ new Map();
+  if (properties) {
+    for (const [key, property] of Object.entries(properties)) {
+      const kind = numericKind(property);
+      if (kind === "scalar") numerics.add(key);
+      else if (kind === "array") numericArrays.add(key);
+      const enumValues = stringEnumValues(property);
+      if (enumValues) values.set(key, new Map(deriveEnumValueMap(enumValues)));
+    }
+  }
+  for (const [key, remaps] of Object.entries(explicit?.values ?? {})) {
+    const map = values.get(key) ?? /* @__PURE__ */ new Map();
+    for (const [spelling, target] of Object.entries(remaps)) {
+      map.set(normalizeForm(spelling), target);
+    }
+    values.set(key, map);
+  }
+  return { declared, declaredForms, singulars, numerics, numericArrays, values, aliases: explicit?.aliases };
+};
+var lexiconRepair = (form, declaredForms) => {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const classForms of KEY_CLASS_FORMS) {
+    if (!classForms.has(form)) continue;
+    for (const [declaredForm, declaredKey] of declaredForms) {
+      if (declaredForm !== form && classForms.has(declaredForm)) {
+        candidates.add(declaredKey);
+      }
+    }
+  }
+  return candidates.size === 1 ? [...candidates][0] : void 0;
+};
+var uniqueDeclaredKeyForSpelling = (spilled, declared) => {
+  if (declared.includes(spilled)) return void 0;
+  const derived = deriveAction(
+    {
+      type: "object",
+      properties: Object.fromEntries(declared.map((key) => [key, {}]))
+    },
+    void 0
+  );
+  const form = normalizeForm(spilled);
+  const canonical = derived.declaredForms.get(form) ?? derived.singulars.get(form) ?? lexiconRepair(form, derived.declaredForms);
+  return canonical && canonical !== spilled ? canonical : void 0;
+};
+var applyDerived = (args, derived) => {
+  const out = { ...args };
+  const repair = (alias, canonical) => {
+    if (!(alias in out) || alias === canonical) return;
+    if (!(canonical in out)) out[canonical] = out[alias];
+    delete out[alias];
+  };
+  for (const [alias, canonical] of Object.entries(derived.aliases ?? {})) {
+    repair(alias, canonical);
+  }
+  for (const key of [...Object.keys(out)]) {
+    if (derived.declared.has(key)) continue;
+    const form = normalizeForm(key);
+    const canonical = derived.declaredForms.get(form) ?? derived.singulars.get(form) ?? lexiconRepair(form, derived.declaredForms);
+    if (canonical && canonical !== key) repair(key, canonical);
+  }
+  for (const key of derived.numerics) {
+    const value = out[key];
+    if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) {
+      out[key] = Number(value);
+    }
+  }
+  for (const key of derived.numericArrays) {
+    const value = out[key];
+    if (Array.isArray(value)) {
+      out[key] = value.map(
+        (entry) => typeof entry === "string" && entry.trim() !== "" && !Number.isNaN(Number(entry)) ? Number(entry) : entry
+      );
+    }
+  }
+  for (const [key, remaps] of derived.values) {
+    const value = out[key];
+    if (typeof value === "string") {
+      const next = remaps.get(normalizeForm(value));
+      if (next !== void 0) out[key] = next;
+    }
+  }
+  if (derived.declared.size > 0) {
+    for (const key of Object.keys(out)) {
+      if (derived.declared.has(key) && (out[key] === null || out[key] === void 0)) {
+        delete out[key];
+      }
+    }
+  }
+  return out;
+};
+var actionArgNormalizer = (describeActions, table = {}) => {
+  const derived = /* @__PURE__ */ new Map();
+  for (const descriptor of describeActions()) {
+    derived.set(
+      descriptor.name,
+      deriveAction(
+        descriptor.inputSchema,
+        table[descriptor.name]
+      )
+    );
+  }
+  return (actionName, args) => {
+    if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+    const action = derived.get(actionName);
+    return action ? applyDerived(args, action) : args;
+  };
+};
+
+// src/providers/memory-provider.ts
+var EXPAND_DEFAULT_MAX_CHARS = 2e4;
+var EXPAND_MAX_CHARS = 24e3;
+var EXPAND_DEFAULT_MAX_ENTRIES = 10;
+var EXPAND_MAX_ENTRIES = 20;
+var EXPAND_MAX_CONTEXT = 100;
+var EXPAND_MAX_EXACT_SELECTORS = 100;
+var SESSIONS_MAX = 500;
+var CONTINUATION_CACHE_TTL_MS = 5 * 6e4;
+var EXPANSION_SNAPSHOT_LIMIT = 2;
+var EXPANSION_SELECTION_LIMIT = 16;
+var sourceIdentity = (file) => {
+  try {
+    const stat = fs.statSync(file, { bigint: true });
+    if (!stat.isFile()) return null;
+    return {
+      device: stat.dev,
+      inode: stat.ino,
+      size: stat.size,
+      modifiedAt: stat.mtimeNs,
+      changedAt: stat.ctimeNs
+    };
+  } catch {
+    return null;
+  }
+};
+var sameSourceIdentity = (left, right) => left.device === right.device && left.inode === right.inode && left.size === right.size && left.modifiedAt === right.modifiedAt && left.changedAt === right.changedAt;
+var liveBranchSignature = (branch) => branch ? `${branch.leafId ?? ""}\0${branch.entries.length}` : null;
+var observeSource = (file, branches, liveBranch) => {
+  const identity = sourceIdentity(file);
+  if (!identity) return null;
+  return {
+    file: path.resolve(file),
+    identity,
+    liveBranchSignature: branches === "active" ? liveBranchSignature(liveBranch) : null
+  };
+};
+var observeSources = (refs, branches, liveResolver) => {
+  const observations = [];
+  for (const ref of refs) {
+    const liveBranch = branches === "active" ? liveResolver?.(ref.file) : void 0;
+    const observation = observeSource(ref.file, branches, liveBranch);
+    if (!observation) return null;
+    observations.push(observation);
+  }
+  return observations;
+};
+var sameSourceObservation = (left, right) => left.file === right.file && sameSourceIdentity(left.identity, right.identity) && left.liveBranchSignature === right.liveBranchSignature;
+var sameSourceObservations = (left, right) => left.length === right.length && left.every(
+  (item, index) => sameSourceObservation(item, right[index])
+);
+var recallContinuationKey = (args) => JSON.stringify([
+  args.query ?? null,
+  args.queryMode ?? "literal",
+  args.queryMatch ?? null,
+  args.expectedSourceHash ?? null,
+  args.expectedLineageFingerprint ?? null,
+  args.branches ?? "active",
+  args.scope ?? "session",
+  args.pageSize ?? RECALL_DEFAULT_PAGE_SIZE,
+  args.snippetChars ?? RECALL_DEFAULT_SNIPPET_CHARS,
+  args.role ?? null,
+  args.tool ?? null,
+  args.ref ?? null,
+  args.provider ?? null,
+  args.action ?? null,
+  args.outcome ?? null,
+  args.since ?? null,
+  args.until ?? null,
+  args.entryRange ? [args.entryRange.first, args.entryRange.last] : null
+]);
+var expansionSnapshotKey = (file, branches) => `${path.resolve(file)}\0${branches}`;
+var expansionSelectionKey = (selection) => JSON.stringify([
+  selection.indices ?? null,
+  selection.entryIds ?? null,
+  selection.operationAddresses ?? null,
+  selection.entryRange ? [selection.entryRange.first, selection.entryRange.last] : null,
+  selection.before ?? 0,
+  selection.after ?? 0
+]);
+var errorOutputSchema = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    message: { type: "string" }
+  },
+  required: ["code", "message"]
+};
+var coverageOutputSchema = {
+  type: "object",
+  properties: {
+    complete: { type: "boolean" },
+    indexedSessions: { type: "number" },
+    eligibleSessions: { type: "number" },
+    staleSessions: { type: "number" },
+    incompleteSessions: { type: "number" },
+    reasons: {
+      type: "array",
+      items: { type: "string" },
+      description: "Stable machine-readable incompleteness codes; empty when complete is true."
+    },
+    error: errorOutputSchema
+  },
+  required: [
+    "complete",
+    "indexedSessions",
+    "eligibleSessions",
+    "staleSessions",
+    "incompleteSessions",
+    "reasons"
+  ]
+};
+var callOutputSchema = (ref) => ({
+  type: "object",
+  properties: {
+    ref: { const: ref },
+    args: { type: "object" }
+  },
+  required: ["ref", "args"]
+});
+var recallEntryOutputSchema = {
+  type: "object",
+  properties: {
+    kind: { const: "entry" },
+    sessionId: { type: "string" },
+    tier: { type: "string", enum: ["hot", "cold"] },
+    index: { type: "number" },
+    entryId: { type: ["string", "null"] },
+    parentId: { type: ["string", "null"] },
+    operationAddress: { type: ["string", "null"] },
+    type: { type: "string" },
+    role: { type: ["string", "null"] },
+    tool: { type: ["string", "null"] },
+    ref: { type: ["string", "null"] },
+    provider: { type: ["string", "null"] },
+    action: { type: ["string", "null"] },
+    timestamp: { type: ["number", "null"] },
+    isError: { type: "boolean" },
+    outcome: { type: "string", enum: ["succeeded", "failed", "aborted", "timed_out"] },
+    score: { type: "number" },
+    snippet: { type: "string" },
+    truncated: { type: "boolean" },
+    follow: callOutputSchema("memory.expand")
+  },
+  required: [
+    "kind",
+    "sessionId",
+    "tier",
+    "index",
+    "entryId",
+    "parentId",
+    "operationAddress",
+    "type",
+    "role",
+    "tool",
+    "ref",
+    "provider",
+    "action",
+    "timestamp",
+    "isError",
+    "score",
+    "snippet",
+    "truncated",
+    "follow"
+  ]
+};
+var recallSessionOutputSchema = {
+  type: "object",
+  properties: {
+    kind: { const: "session" },
+    sessionId: { type: "string" },
+    tier: { const: "cold" },
+    cwd: { type: "string" },
+    lastTimestamp: { type: ["number", "null"] },
+    score: { type: "number" },
+    matchedTerms: { type: "number" },
+    matchedStructuralEntries: { type: "number" },
+    follow: callOutputSchema("memory.recall")
+  },
+  required: [
+    "kind",
+    "sessionId",
+    "tier",
+    "cwd",
+    "lastTimestamp",
+    "score",
+    "matchedTerms",
+    "matchedStructuralEntries",
+    "follow"
+  ]
+};
+var recallOutputSchema = {
+  type: "object",
+  description: "Bounded ranked memory hits with uniform follow and pagination calls.",
+  properties: {
+    total: { type: "number" },
+    hits: {
+      type: "array",
+      description: "Call tools.call(hit.follow) to expand an entry or resolve a cold session.",
+      items: { oneOf: [recallEntryOutputSchema, recallSessionOutputSchema] }
+    },
+    next: {
+      oneOf: [callOutputSchema("memory.recall"), { type: "null" }],
+      description: "When non-null, call tools.call(next)."
+    },
+    coverage: coverageOutputSchema,
+    error: errorOutputSchema
+  },
+  required: ["total", "hits", "next", "coverage"]
+};
+var expandOutputSchema = {
+  type: "object",
+  description: "Integrity-bound session entries returned as lossless bounded text chunks.",
+  properties: {
+    session: { type: "string" },
+    sourceHash: { type: "string" },
+    branches: { type: "string", enum: ["active", "all"] },
+    lineageFingerprint: { type: "string" },
+    entryCount: { type: "number" },
+    entries: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          index: { type: "number" },
+          entryId: { type: ["string", "null"] },
+          parentId: { type: ["string", "null"] },
+          type: { type: ["string", "null"] },
+          role: { type: ["string", "null"] },
+          timestamp: { type: ["number", "null"] },
+          isError: { type: "boolean" },
+          text: { type: "string" },
+          textRange: {
+            type: "object",
+            properties: {
+              start: { type: "number" },
+              end: { type: "number" },
+              total: { type: "number" },
+              complete: { type: "boolean" }
+            },
+            required: ["start", "end", "total", "complete"]
+          },
+          anchor: { type: "boolean" },
+          parentEntryId: { type: ["string", "null"] },
+          operationAddress: { type: ["string", "null"] },
+          tool: { type: ["string", "null"] },
+          ref: { type: ["string", "null"] },
+          provider: { type: ["string", "null"] },
+          action: { type: ["string", "null"] },
+          outcome: { type: "string", enum: ["succeeded", "failed", "aborted", "timed_out"] },
+          filesTouched: { type: "array", items: { type: ["string", "null"] } },
+          operation: { type: "object" },
+          branchFact: { type: "object" },
+          structuredTruncated: { type: "boolean" },
+          factAddress: { type: ["string", "null"] },
+          carrierEntryId: { type: ["string", "null"] },
+          carrierParentId: { type: ["string", "null"] },
+          carrierFromId: { type: ["string", "null"] }
+        },
+        required: ["index", "entryId", "parentId", "type", "role", "timestamp", "isError", "text", "textRange"]
+      }
+    },
+    next: {
+      oneOf: [callOutputSchema("memory.expand"), { type: "null" }],
+      description: "When non-null, call tools.call(next)."
+    },
+    error: errorOutputSchema
+  },
+  required: ["entries"]
+};
+var sessionsOutputSchema = {
+  type: "object",
+  properties: {
+    scope: { type: "string" },
+    branches: { type: "string", enum: ["active", "all"] },
+    sessions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          file: { type: "string" },
+          cwd: { type: "string" },
+          mtime: { type: "number" },
+          entryCount: { type: "number" },
+          tier: { type: "string", enum: ["hot", "cold"] },
+          branches: { type: "string", enum: ["active", "all"] },
+          lineageFingerprint: { type: ["string", "null"] }
+        },
+        required: [
+          "id",
+          "file",
+          "cwd",
+          "mtime",
+          "entryCount",
+          "tier",
+          "branches",
+          "lineageFingerprint"
+        ]
+      }
+    },
+    error: errorOutputSchema
+  }
+};
+var descriptors = [
+  {
+    name: "recall",
+    description: "Search session memory as bounded ranked snippets. Literal queries rank any matching term by default; queryMatch all narrows to co-located terms. Call tools.call(hit.follow) for either an exact entry or a cold-session candidate, and tools.call(next) to continue.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", maxLength: 4096 },
+        queryMode: {
+          type: "string",
+          enum: ["literal", "phrase", "regex"],
+          default: "literal",
+          description: "Canonical tokens (default), one case-insensitive exact phrase, or explicitly bounded regex."
+        },
+        queryMatch: {
+          type: "string",
+          enum: ["all", "any"],
+          default: "any",
+          description: "For literal mode, accept any term (default) or require all terms in one hot entry."
+        },
+        expectedSourceHash: {
+          type: "string",
+          description: "SHA-256 from a prior pointer; stale sources are refused."
+        },
+        expectedLineageFingerprint: {
+          type: "string",
+          description: "Active-lineage fingerprint from a prior pointer; changed leaves are refused."
+        },
+        branches: {
+          type: "string",
+          enum: ["active", "all"],
+          description: "Search the active parent-linked path (default) or every branch."
+        },
+        scope: {
+          type: "string",
+          description: "session | project | global | session:<id-or-path>. Defaults to session."
+        },
+        offset: {
+          type: "number",
+          minimum: 0,
+          description: "Exact ranked-hit offset, normally copied from next.args."
+        },
+        pageSize: { type: "number", minimum: 1, maximum: RECALL_MAX_PAGE_SIZE, default: RECALL_DEFAULT_PAGE_SIZE },
+        snippetChars: {
+          type: "number",
+          minimum: 80,
+          maximum: RECALL_MAX_SNIPPET_CHARS,
+          default: RECALL_DEFAULT_SNIPPET_CHARS,
+          description: "Maximum indexed-text characters shown per hit; full text remains in memory.expand."
+        },
+        role: {
+          type: "string",
+          enum: [
+            "assistant",
+            "bashExecution",
+            "branchCustomMessage",
+            "branchSummary",
+            "branchUser",
+            "compaction",
+            "compactionSummary",
+            "custom",
+            "fabricOperation",
+            "fabricPhase",
+            "fabricRun",
+            "toolResult",
+            "user"
+          ],
+          description: "Exact normalized entry role to filter by: the closed set the session normalizer can produce."
+        },
+        tool: { type: "string" },
+        ref: {
+          type: "string",
+          minLength: 1,
+          description: "Exact persisted Fabric action ref, such as omp.grep. This is structural selection, not lexical expansion."
+        },
+        provider: {
+          type: "string",
+          minLength: 1,
+          description: "Exact persisted Fabric provider identity."
+        },
+        action: {
+          type: "string",
+          minLength: 1,
+          description: "Exact persisted Fabric action name."
+        },
+        outcome: {
+          type: "string",
+          enum: ["succeeded", "failed", "aborted", "timed_out"],
+          description: "Exact persisted Fabric execution outcome."
+        },
+        since: { type: "number" },
+        until: { type: "number" },
+        entryRange: {
+          type: "object",
+          description: "Inclusive normalized-entry range for an explicit session:<id> resolution.",
+          properties: {
+            first: { type: "number", minimum: 0 },
+            last: { type: "number", minimum: 0 }
+          },
+          required: ["first", "last"],
+          additionalProperties: false
+        }
+      },
+      additionalProperties: false
+    },
+    outputSchema: recallOutputSchema,
+    risk: "read",
+    namespace: "memory"
+  },
+  {
+    name: "expand",
+    description: "Read exact normalized session entries and nearby context as bounded lossless chunks. Call tools.call(next) to continue, or use guest-side memory.walk(args, visitor) to traverse complete reassembled entries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session: { type: "string", description: "Exact session file path or unambiguous id." },
+        expectedSourceHash: {
+          type: "string",
+          description: "SHA-256 from a prior pointer; stale sources are refused."
+        },
+        expectedLineageFingerprint: {
+          type: "string",
+          description: "Active-lineage fingerprint from a prior pointer; changed leaves are refused."
+        },
+        branches: {
+          type: "string",
+          enum: ["active", "all"],
+          description: "Expand on the active parent-linked path (default) or across every branch."
+        },
+        indices: { type: "array", maxItems: EXPAND_MAX_EXACT_SELECTORS, items: { type: "number", minimum: 0 } },
+        entryIds: { type: "array", maxItems: EXPAND_MAX_EXACT_SELECTORS, items: { type: "string", maxLength: 512 } },
+        operationAddresses: { type: "array", maxItems: EXPAND_MAX_EXACT_SELECTORS, items: { type: "string", maxLength: 512 } },
+        entryRange: {
+          type: "object",
+          properties: {
+            first: { type: "number", minimum: 0 },
+            last: { type: "number", minimum: 0 }
+          },
+          required: ["first", "last"],
+          additionalProperties: false
+        },
+        before: {
+          type: "number",
+          minimum: 0,
+          maximum: EXPAND_MAX_CONTEXT,
+          default: 0,
+          description: "Entries before one exact selected anchor."
+        },
+        after: {
+          type: "number",
+          minimum: 0,
+          maximum: EXPAND_MAX_CONTEXT,
+          default: 0,
+          description: "Entries after one exact selected anchor."
+        },
+        entryOffset: {
+          type: "number",
+          minimum: 0,
+          description: "Continuation offset within the resolved selection; copy from next.args."
+        },
+        textOffset: {
+          type: "number",
+          minimum: 0,
+          description: "Continuation offset within the first returned entry; copy from next.args."
+        },
+        maxChars: {
+          type: "number",
+          minimum: 256,
+          maximum: EXPAND_MAX_CHARS,
+          default: EXPAND_DEFAULT_MAX_CHARS,
+          description: "Total entry-text characters returned in this chunk."
+        },
+        maxEntries: {
+          type: "number",
+          minimum: 1,
+          maximum: EXPAND_MAX_ENTRIES,
+          default: EXPAND_DEFAULT_MAX_ENTRIES,
+          description: "Maximum complete or partial entries returned in this chunk."
+        }
+      },
+      required: ["session"],
+      additionalProperties: false
+    },
+    outputSchema: expandOutputSchema,
+    risk: "read",
+    namespace: "memory"
+  },
+  {
+    name: "sessions",
+    description: "List known sessions in scope with id, file, cwd, mtime, entry count, and hot/cold tier.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scope: { type: "string" },
+        branches: {
+          type: "string",
+          enum: ["active", "all"],
+          description: "Count the active parent-linked path (default) or every branch."
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          description: "Maximum sessions returned; capped at the internal session ceiling."
+        }
+      },
+      additionalProperties: false
+    },
+    outputSchema: sessionsOutputSchema,
+    risk: "read",
+    namespace: "memory"
+  }
+];
+var MEMORY_SCOPE_VALUE_ALIASES = {
+  cwd: "project",
+  repo: "project",
+  directory: "project",
+  folder: "project",
+  all: "global",
+  current: "session"
+};
+var MEMORY_ARG_NORMALIZATION = {
+  recall: { values: { scope: MEMORY_SCOPE_VALUE_ALIASES } },
+  sessions: { values: { scope: MEMORY_SCOPE_VALUE_ALIASES } }
+};
+var normalizeMemoryArgs = actionArgNormalizer(
+  () => descriptors,
+  MEMORY_ARG_NORMALIZATION
+);
+var parseBranches = (value, action) => {
+  if (value === void 0) return "active";
+  if (value === "active" || value === "all") return value;
+  throw new Error(`${action} branches must be "active" or "all"`);
+};
+var resolveIndexOptions = (config, agentDir, branches, liveBranchForFile) => ({
+  indexDir: config.indexDir ?? `${agentDir}/fabric/memory-index`,
+  maxEntryChars: config.maxEntryChars,
+  branches,
+  indexThinking: config.indexThinking ?? false,
+  indexToolOutput: config.indexToolOutput ?? true,
+  ...liveBranchForFile ? { liveBranchForFile } : {},
+  hotSessions: config.hotSessions ?? DEFAULT_HOT_SESSIONS,
+  digestTerms: config.digestTerms ?? 200,
+  ...config.maxColdVocabularyBytes === void 0 ? {} : { maxColdVocabularyBytes: config.maxColdVocabularyBytes },
+  ...config.maxColdCacheBytes === void 0 ? {} : { maxColdCacheBytes: config.maxColdCacheBytes },
+  ...config.maxSyncSessions === void 0 ? {} : { maxSyncSessions: config.maxSyncSessions },
+  ...config.maxSyncSourceBytes === void 0 ? {} : { maxSyncSourceBytes: config.maxSyncSourceBytes },
+  ...config.maxCacheCleanupFiles === void 0 ? {} : { maxCacheCleanupFiles: config.maxCacheCleanupFiles }
+});
+var resolveTierRefs = (refs, context) => {
+  const all = enumerateAllSessions(context.agentDir, Number.MAX_SAFE_INTEGER);
+  const known = new Set(all.map((ref) => ref.file));
+  for (const ref of refs) {
+    if (!known.has(ref.file)) all.push(ref);
+  }
+  return all;
+};
+var resolveRefs = (scope, context, boundedBrowse) => {
+  const effectiveScope = scope ?? "session";
+  const input = {
+    agentDir: context.agentDir,
+    cwd: context.cwd,
+    scope: effectiveScope,
+    maxSessions: boundedBrowse ? context.config.maxSessions : Number.MAX_SAFE_INTEGER
+  };
+  if (context.sessionId) input.sessionId = context.sessionId;
+  if (context.sessionFile) input.sessionFile = context.sessionFile;
+  return resolveScope(input);
+};
+var liveBranchResolver = (context) => {
+  if (!context.sessionFile || !context.getLiveBranch) return void 0;
+  const current = path.resolve(context.sessionFile);
+  return (sessionFile) => path.resolve(sessionFile) === current ? context.getLiveBranch?.() : void 0;
+};
+var stalePointerError = (sessionFile, expectedSourceHash, actualSourceHash, expectedLineageFingerprint, actualLineageFingerprint) => ({
+  code: "stale_pointer",
+  message: expectedLineageFingerprint !== void 0 && expectedLineageFingerprint !== actualLineageFingerprint ? "Session active lineage changed after the pointer was issued." : "Session source changed after the pointer was issued.",
+  sessionFile,
+  ...expectedSourceHash === void 0 ? {} : { expectedSourceHash },
+  actualSourceHash,
+  ...expectedLineageFingerprint === void 0 ? {} : { expectedLineageFingerprint },
+  ...actualLineageFingerprint === void 0 ? {} : { actualLineageFingerprint }
+});
+var addressError = (message, entryCount) => ({
+  code: "index_out_of_bounds",
+  message,
+  ...entryCount === void 0 ? {} : { entryCount }
+});
+var recallFailure = (error) => ({
+  total: 0,
+  hits: [],
+  next: null,
+  coverage: {
+    complete: false,
+    indexedSessions: 0,
+    eligibleSessions: 0,
+    staleSessions: 0,
+    incompleteSessions: 0,
+    reasons: [error.code]
+  },
+  error
+});
+var MemoryProvider = class {
+  constructor(context) {
+    this.context = context;
+  }
+  name = "memory";
+  description = "Cross-session memory: a search engine over every OMP session timeline on this machine";
+  recallContinuation;
+  expansionSnapshots = /* @__PURE__ */ new Map();
+  cachedRecallContinuation(key, observations) {
+    const cached = this.recallContinuation;
+    if (!cached || cached.key !== key) return void 0;
+    if (!observations || Date.now() - cached.touchedAt > CONTINUATION_CACHE_TTL_MS || !sameSourceObservations(cached.observations, observations)) {
+      this.recallContinuation = void 0;
+      return void 0;
+    }
+    cached.touchedAt = Date.now();
+    return cached;
+  }
+  rememberRecallContinuation(cached) {
+    this.recallContinuation = cached;
+  }
+  forgetRecallContinuation(cached) {
+    if (this.recallContinuation === cached) this.recallContinuation = void 0;
+  }
+  cachedExpansionSnapshot(file, branches, observation) {
+    const key = expansionSnapshotKey(file, branches);
+    const cached = this.expansionSnapshots.get(key);
+    if (!cached) return void 0;
+    if (!observation || Date.now() - cached.touchedAt > CONTINUATION_CACHE_TTL_MS || !sameSourceObservation(cached.observation, observation)) {
+      this.expansionSnapshots.delete(key);
+      return void 0;
+    }
+    cached.touchedAt = Date.now();
+    this.expansionSnapshots.delete(key);
+    this.expansionSnapshots.set(key, cached);
+    return cached;
+  }
+  rememberExpansionSnapshot(snapshot) {
+    const key = expansionSnapshotKey(snapshot.file, snapshot.branches);
+    this.expansionSnapshots.delete(key);
+    this.expansionSnapshots.set(key, snapshot);
+    while (this.expansionSnapshots.size > EXPANSION_SNAPSHOT_LIMIT) {
+      const oldest = this.expansionSnapshots.keys().next().value;
+      if (oldest === void 0) break;
+      this.expansionSnapshots.delete(oldest);
+    }
+  }
+  rememberExpansionSelection(snapshot, keys, selection) {
+    for (const key of new Set(keys)) {
+      snapshot.selections.delete(key);
+      snapshot.selections.set(key, selection);
+    }
+    while (snapshot.selections.size > EXPANSION_SELECTION_LIMIT) {
+      const oldest = snapshot.selections.keys().next().value;
+      if (oldest === void 0) break;
+      snapshot.selections.delete(oldest);
+    }
+  }
+  forgetExpansionSnapshot(snapshot) {
+    const key = expansionSnapshotKey(snapshot.file, snapshot.branches);
+    if (this.expansionSnapshots.get(key) === snapshot) this.expansionSnapshots.delete(key);
+  }
+  async list(request, _context) {
+    const query = request.query?.toLowerCase();
+    return query ? descriptors.filter(
+      (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
+    ) : descriptors;
+  }
+  async describe(actionName, _context) {
+    return descriptors.find((descriptor) => descriptor.name === actionName);
+  }
+  prepareArguments(actionName, args) {
+    return normalizeMemoryArgs(actionName, args);
+  }
+  async invoke(actionName, args, invocationContext) {
+    try {
+      switch (actionName) {
+        case "recall":
+          return await this.recall(args, invocationContext);
+        case "expand":
+          return await this.expand(args);
+        case "sessions":
+          return await this.sessions(args);
+        default:
+          throw new Error(`Unknown memory action: ${actionName}`);
+      }
+    } catch (error) {
+      if (error instanceof AmbiguousSessionError) {
+        const detail = {
+          code: error.code,
+          message: error.message,
+          session: error.session,
+          candidates: error.candidates
+        };
+        if (actionName === "recall") return recallFailure(detail);
+        if (actionName === "expand") return { entries: [], next: null, error: detail };
+        return { error: detail };
+      }
+      throw error;
+    }
+  }
+  async recall(args, invocationContext) {
+    const query = typeof args.query === "string" ? args.query : void 0;
+    const rawQueryMode = args.queryMode;
+    if (rawQueryMode !== void 0 && rawQueryMode !== "literal" && rawQueryMode !== "phrase" && rawQueryMode !== "regex") {
+      throw new Error('memory.recall queryMode must be "literal", "phrase", or "regex"');
+    }
+    const queryMode = rawQueryMode === "phrase" ? "phrase" : rawQueryMode === "regex" ? "regex" : "literal";
+    const rawQueryMatch = args.queryMatch;
+    if (rawQueryMatch !== void 0 && rawQueryMatch !== "all" && rawQueryMatch !== "any") {
+      throw new Error('memory.recall queryMatch must be "all" or "any"');
+    }
+    if (queryMode !== "literal" && rawQueryMatch !== void 0) {
+      throw new Error("memory.recall queryMatch is only valid with literal queryMode");
+    }
+    const queryMatch = rawQueryMatch === "all" ? "all" : "any";
+    const expectedSourceHash = typeof args.expectedSourceHash === "string" ? args.expectedSourceHash : void 0;
+    const expectedLineageFingerprint = typeof args.expectedLineageFingerprint === "string" ? args.expectedLineageFingerprint : void 0;
+    const branches = parseBranches(args.branches, "memory.recall");
+    const scope = typeof args.scope === "string" ? args.scope : void 0;
+    const role = typeof args.role === "string" ? args.role : void 0;
+    const tool = typeof args.tool === "string" ? args.tool : void 0;
+    const ref = typeof args.ref === "string" ? args.ref : void 0;
+    const provider = typeof args.provider === "string" ? args.provider : void 0;
+    const action = typeof args.action === "string" ? args.action : void 0;
+    const rawOutcome = args.outcome;
+    if (rawOutcome !== void 0 && rawOutcome !== "succeeded" && rawOutcome !== "failed" && rawOutcome !== "aborted" && rawOutcome !== "timed_out") {
+      throw new Error("memory.recall outcome must be succeeded, failed, aborted, or timed_out");
+    }
+    const outcome = rawOutcome;
+    const since = typeof args.since === "number" ? args.since : void 0;
+    const until = typeof args.until === "number" ? args.until : void 0;
+    const offset = typeof args.offset === "number" && args.offset >= 0 ? Math.floor(args.offset) : void 0;
+    const pageSize = typeof args.pageSize === "number" && args.pageSize >= 1 ? Math.min(Math.floor(args.pageSize), RECALL_MAX_PAGE_SIZE) : RECALL_DEFAULT_PAGE_SIZE;
+    const snippetChars = typeof args.snippetChars === "number" && args.snippetChars >= 80 ? Math.min(Math.floor(args.snippetChars), RECALL_MAX_SNIPPET_CHARS) : RECALL_DEFAULT_SNIPPET_CHARS;
+    const refs = resolveRefs(scope, this.context, false);
+    const liveResolver = liveBranchResolver(this.context);
+    const options = resolveIndexOptions(
+      this.context.config,
+      this.context.agentDir,
+      branches,
+      liveResolver
+    );
+    const hydrate = scope?.trim().startsWith("session:") ?? false;
+    if ((expectedSourceHash !== void 0 || expectedLineageFingerprint !== void 0) && !hydrate) {
+      throw new Error("memory.recall integrity expectations require scope session:<id-or-path>");
+    }
+    const rawRange = args.entryRange;
+    const entryRange = rawRange && typeof rawRange === "object" && !Array.isArray(rawRange) ? rawRange : void 0;
+    const first = entryRange?.first;
+    const last = entryRange?.last;
+    if (first === void 0 !== (last === void 0)) {
+      throw new Error("memory.recall entryRange requires both first and last");
+    }
+    if ((first !== void 0 || last !== void 0) && !hydrate) {
+      throw new Error("memory.recall entryRange requires scope session:<id-or-path>");
+    }
+    if (first !== void 0 && (typeof first !== "number" || typeof last !== "number" || !Number.isSafeInteger(first) || !Number.isSafeInteger(last) || first < 0 || last < first)) {
+      return recallFailure(addressError("Entry range requires safe integers with 0 <= first <= last."));
+    }
+    const selectedRange = typeof first === "number" && typeof last === "number" ? { first, last } : void 0;
+    const filters = {};
+    if (role) filters.role = role;
+    if (tool) filters.tool = tool;
+    if (ref) filters.ref = ref;
+    if (provider) filters.provider = provider;
+    if (action) filters.action = action;
+    if (outcome) filters.outcome = outcome;
+    if (since !== void 0) filters.since = since;
+    if (until !== void 0) filters.until = until;
+    const baseRequestArgs = {
+      ...query === void 0 ? {} : { query },
+      queryMode,
+      ...queryMode === "literal" ? { queryMatch } : {},
+      ...expectedSourceHash ? { expectedSourceHash } : {},
+      ...expectedLineageFingerprint ? { expectedLineageFingerprint } : {},
+      branches,
+      scope: scope ?? "session",
+      ...offset === void 0 ? {} : { offset },
+      pageSize,
+      snippetChars,
+      ...role ? { role } : {},
+      ...tool ? { tool } : {},
+      ...ref ? { ref } : {},
+      ...provider ? { provider } : {},
+      ...action ? { action } : {},
+      ...outcome ? { outcome } : {},
+      ...since !== void 0 ? { since } : {},
+      ...until !== void 0 ? { until } : {},
+      ...selectedRange ? { entryRange: selectedRange } : {}
+    };
+    const updateProgress = (searchResult) => {
+      invocationContext.update(
+        searchResult.matchMode === "structural" ? `memory.recall: ${searchResult.matchedCount} structural matches` : searchResult.matchMode === "combined" ? `memory.recall: ${searchResult.matchedCount} filtered matches` : query ? `memory.recall: ${searchResult.matchedCount} matches` : `memory.recall: ${searchResult.matchedCount} recent entries`
+      );
+    };
+    const observationsBefore = observeSources(refs, branches, liveResolver);
+    const cached = offset === void 0 ? void 0 : this.cachedRecallContinuation(
+      recallContinuationKey(baseRequestArgs),
+      observationsBefore
+    );
+    if (cached) {
+      const response2 = presentRecall({
+        result: cached.result,
+        ...query === void 0 ? {} : { query },
+        queryMode,
+        coverage: cached.coverage,
+        ...offset === void 0 ? {} : { offset },
+        pageSize,
+        snippetChars,
+        requestArgs: cached.requestArgs
+      });
+      const observationsAfterCachedPage = observeSources(refs, branches, liveResolver);
+      if (observationsBefore && observationsAfterCachedPage && sameSourceObservations(observationsBefore, observationsAfterCachedPage)) {
+        if (response2.next === null) this.forgetRecallContinuation(cached);
+        updateProgress(cached.result);
+        return response2;
+      }
+      this.forgetRecallContinuation(cached);
+    }
+    if (hydrate && refs[0]) {
+      const state = fingerprintSource(refs[0].file);
+      const lineage = reconstructSessionLineage(
+        refs[0].file,
+        branches,
+        liveResolver?.(refs[0].file)
+      );
+      const sourceChanged = expectedSourceHash !== void 0 && state?.sourceHash !== expectedSourceHash;
+      const lineageChanged = expectedLineageFingerprint !== void 0 && lineage.fingerprint !== expectedLineageFingerprint;
+      if (state && (sourceChanged || lineageChanged)) {
+        return recallFailure(stalePointerError(
+          refs[0].file,
+          expectedSourceHash,
+          state.sourceHash,
+          expectedLineageFingerprint,
+          lineage.fingerprint
+        ));
+      }
+    }
+    const index = loadTieredIndex(
+      refs,
+      resolveTierRefs(refs, this.context),
+      options,
+      hydrate,
+      selectedRange
+    );
+    const hydratedShard = index.shards[0];
+    const hydratedSourceChanged = expectedSourceHash !== void 0 && hydratedShard?.sourceHash !== expectedSourceHash;
+    const hydratedLineageChanged = expectedLineageFingerprint !== void 0 && hydratedShard?.lineageFingerprint !== expectedLineageFingerprint;
+    if (hydrate && hydratedShard && (hydratedSourceChanged || hydratedLineageChanged)) {
+      return recallFailure(stalePointerError(
+        hydratedShard.sessionFile,
+        expectedSourceHash,
+        hydratedShard.sourceHash,
+        expectedLineageFingerprint,
+        hydratedShard.lineageFingerprint
+      ));
+    }
+    if (hydrate && selectedRange && index.shards[0] && selectedRange.last >= index.shards[0].totalEntryCount) {
+      return recallFailure(addressError(
+        `Entry range ends at ${selectedRange.last}, but the session has ${index.shards[0].totalEntryCount} entries.`,
+        index.shards[0].totalEntryCount
+      ));
+    }
+    const searchQuery = {
+      ...query === void 0 ? {} : { query },
+      queryMode,
+      queryMatch,
+      filters,
+      regexLimits: {
+        maxPatternBytes: this.context.config.regexMaxPatternBytes ?? DEFAULT_REGEX_MAX_PATTERN_BYTES,
+        maxHaystackTerms: this.context.config.regexMaxHaystackTerms ?? DEFAULT_REGEX_MAX_HAYSTACK_TERMS,
+        maxHaystackBytes: this.context.config.regexMaxHaystackBytes ?? DEFAULT_REGEX_MAX_HAYSTACK_BYTES,
+        timeoutMs: this.context.config.regexTimeoutMs ?? DEFAULT_REGEX_TIMEOUT_MS
+      }
+    };
+    const result = await searchMemoryIndex(index.shards, index.digests, searchQuery);
+    const coverage = {
+      ...index.coverage,
+      complete: index.coverage.complete && result.queryCoverage.complete,
+      reasons: [.../* @__PURE__ */ new Set([...index.coverage.reasons, ...result.queryCoverage.reasons])].sort(),
+      ...result.queryCoverage.error ? { error: result.queryCoverage.error } : {}
+    };
+    const soleRef = refs.length === 1 ? refs[0] : void 0;
+    const soleShard = soleRef ? index.shards.find((candidate) => candidate.sessionFile === soleRef.file) : void 0;
+    const soleDigest = soleRef ? index.digests.find((candidate) => candidate.file === soleRef.file) : void 0;
+    const continuationBinding = soleRef && (soleShard?.sourceHash || soleDigest?.sourceHash) ? {
+      file: soleRef.file,
+      sourceHash: soleShard?.sourceHash ?? soleDigest.sourceHash,
+      lineageFingerprint: soleShard?.lineageFingerprint ?? soleDigest.lineageFingerprint
+    } : void 0;
+    const requestArgs = {
+      ...baseRequestArgs,
+      ...expectedSourceHash ?? continuationBinding?.sourceHash ? { expectedSourceHash: expectedSourceHash ?? continuationBinding.sourceHash } : {},
+      ...expectedLineageFingerprint ?? continuationBinding?.lineageFingerprint ? {
+        expectedLineageFingerprint: expectedLineageFingerprint ?? continuationBinding.lineageFingerprint
+      } : {},
+      scope: continuationBinding ? `session:${continuationBinding.file}` : baseRequestArgs.scope ?? "session"
+    };
+    const response = presentRecall({
+      result,
+      ...query === void 0 ? {} : { query },
+      queryMode,
+      coverage,
+      ...offset === void 0 ? {} : { offset },
+      pageSize,
+      snippetChars,
+      requestArgs
+    });
+    const observationsAfter = observeSources(refs, branches, liveResolver);
+    if (response.next !== null && observationsBefore && observationsAfter && sameSourceObservations(observationsBefore, observationsAfter)) {
+      this.rememberRecallContinuation({
+        key: recallContinuationKey(requestArgs),
+        result,
+        coverage,
+        requestArgs,
+        observations: observationsAfter,
+        touchedAt: Date.now()
+      });
+    }
+    updateProgress(result);
+    return response;
+  }
+  async expand(args) {
+    const session = typeof args.session === "string" ? args.session : "";
+    const expectedSourceHash = typeof args.expectedSourceHash === "string" ? args.expectedSourceHash : void 0;
+    const expectedLineageFingerprint = typeof args.expectedLineageFingerprint === "string" ? args.expectedLineageFingerprint : void 0;
+    const branches = parseBranches(args.branches, "memory.expand");
+    const rawIndices = args.indices;
+    if (rawIndices !== void 0 && !Array.isArray(rawIndices)) {
+      throw new Error("memory.expand indices must be an array");
+    }
+    if (Array.isArray(rawIndices) && !rawIndices.every((index) => typeof index === "number" && Number.isSafeInteger(index) && index >= 0)) {
+      return { session, error: addressError("Every entry index must be a non-negative safe integer."), entries: [] };
+    }
+    const indices = rawIndices ?? [];
+    const entryIds = Array.isArray(args.entryIds) ? args.entryIds.filter(
+      (entryId) => typeof entryId === "string" && entryId.length > 0
+    ) : [];
+    const operationAddresses = Array.isArray(args.operationAddresses) ? args.operationAddresses.filter(
+      (address) => typeof address === "string" && address.length > 0
+    ) : [];
+    if (indices.length + entryIds.length + operationAddresses.length > EXPAND_MAX_EXACT_SELECTORS) {
+      throw new Error(`memory.expand accepts at most ${EXPAND_MAX_EXACT_SELECTORS} exact selectors per call`);
+    }
+    const rawRange = args.entryRange;
+    const rangeRecord = rawRange && typeof rawRange === "object" && !Array.isArray(rawRange) ? rawRange : void 0;
+    const first = rangeRecord?.first;
+    const last = rangeRecord?.last;
+    if (!session) throw new Error("memory.expand requires a session");
+    if (first === void 0 !== (last === void 0)) {
+      throw new Error("memory.expand entryRange requires both first and last");
+    }
+    if (first !== void 0 && (typeof first !== "number" || typeof last !== "number" || !Number.isSafeInteger(first) || !Number.isSafeInteger(last) || first < 0 || last < first)) {
+      return { session, error: addressError("Entry range requires safe integers with 0 <= first <= last."), entries: [] };
+    }
+    const numeric = (value, fallback, maximum) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? Math.min(value, maximum) : fallback;
+    const before = numeric(args.before, 0, EXPAND_MAX_CONTEXT);
+    const after = numeric(args.after, 0, EXPAND_MAX_CONTEXT);
+    const entryOffset = numeric(args.entryOffset, 0, Number.MAX_SAFE_INTEGER);
+    const textOffset = numeric(args.textOffset, 0, Number.MAX_SAFE_INTEGER);
+    const maxChars = Math.max(256, numeric(args.maxChars, EXPAND_DEFAULT_MAX_CHARS, EXPAND_MAX_CHARS));
+    const maxEntries = Math.max(1, numeric(args.maxEntries, EXPAND_DEFAULT_MAX_ENTRIES, EXPAND_MAX_ENTRIES));
+    const ref = resolveSessionTarget(this.context.agentDir, session);
+    if (!ref) {
+      return {
+        session,
+        error: { code: "session_not_found", message: `Session not found: ${session}` },
+        entries: []
+      };
+    }
+    const liveResolver = liveBranchResolver(this.context);
+    const observedLiveBranch = branches === "active" ? liveResolver?.(ref.file) : void 0;
+    const observedSource = observeSource(ref.file, branches, observedLiveBranch);
+    let snapshot = this.cachedExpansionSnapshot(ref.file, branches, observedSource);
+    if (snapshot) {
+      const sourceChanged = expectedSourceHash !== void 0 && snapshot.sourceHash !== expectedSourceHash;
+      const lineageChanged = expectedLineageFingerprint !== void 0 && snapshot.lineageFingerprint !== expectedLineageFingerprint;
+      if (sourceChanged || lineageChanged) {
+        return {
+          session: ref.file,
+          branches,
+          error: stalePointerError(
+            ref.file,
+            expectedSourceHash,
+            snapshot.sourceHash,
+            expectedLineageFingerprint,
+            snapshot.lineageFingerprint
+          ),
+          entries: []
+        };
+      }
+    }
+    if (!snapshot) {
+      const initialState = fingerprintSource(ref.file);
+      if (!initialState) {
+        return {
+          session: ref.file,
+          error: { code: "source_unavailable", message: `Session source is unavailable: ${ref.file}` },
+          entries: []
+        };
+      }
+      const initialLiveBranch = branches === "active" ? liveResolver?.(ref.file) : void 0;
+      const initialLineage = reconstructSessionLineage(
+        ref.file,
+        branches,
+        initialLiveBranch
+      );
+      const sourceChanged = expectedSourceHash !== void 0 && initialState.sourceHash !== expectedSourceHash;
+      const lineageChanged = expectedLineageFingerprint !== void 0 && initialLineage.fingerprint !== expectedLineageFingerprint;
+      if (sourceChanged || lineageChanged) {
+        return {
+          session: ref.file,
+          branches,
+          error: stalePointerError(
+            ref.file,
+            expectedSourceHash,
+            initialState.sourceHash,
+            expectedLineageFingerprint,
+            initialLineage.fingerprint
+          ),
+          entries: []
+        };
+      }
+      const normalized = normalizeSession(
+        ref.file,
+        Number.MAX_SAFE_INTEGER,
+        {
+          lineage: initialLineage,
+          indexThinking: true,
+          indexToolOutput: true
+        }
+      ).entries;
+      const finalState2 = fingerprintSource(ref.file);
+      const finalLiveBranch = branches === "active" ? liveResolver?.(ref.file) : void 0;
+      const finalLineage2 = reconstructSessionLineage(
+        ref.file,
+        branches,
+        finalLiveBranch
+      );
+      const finalObservation = observeSource(ref.file, branches, finalLiveBranch);
+      if (!finalState2 || !finalObservation || finalState2.sourceHash !== initialState.sourceHash || finalLineage2.fingerprint !== initialLineage.fingerprint) {
+        return {
+          session: ref.file,
+          error: stalePointerError(
+            ref.file,
+            expectedSourceHash ?? initialState.sourceHash,
+            finalState2?.sourceHash ?? "",
+            expectedLineageFingerprint ?? initialLineage.fingerprint,
+            finalLineage2.fingerprint
+          ),
+          entries: []
+        };
+      }
+      snapshot = {
+        file: ref.file,
+        branches,
+        sourceHash: finalState2.sourceHash,
+        lineageFingerprint: finalLineage2.fingerprint,
+        observation: finalObservation,
+        entries: normalized,
+        selections: /* @__PURE__ */ new Map(),
+        touchedAt: Date.now()
+      };
+    }
+    const entryCount = snapshot.entries.length;
+    const outOfBounds = indices.find((index) => index >= entryCount);
+    if (outOfBounds !== void 0) {
+      return {
+        session: ref.file,
+        error: addressError(`Entry index ${outOfBounds} is outside 0..${Math.max(0, entryCount - 1)}.`, entryCount),
+        entries: []
+      };
+    }
+    if (typeof last === "number" && last >= entryCount) {
+      return {
+        session: ref.file,
+        error: addressError(`Entry range ends at ${last}, but the session has ${entryCount} entries.`, entryCount),
+        entries: []
+      };
+    }
+    if (indices.length === 0 && entryIds.length === 0 && operationAddresses.length === 0 && (first === void 0 || last === void 0)) {
+      if (before > 0 || after > 0) {
+        throw new Error("memory.expand before/after requires one selected anchor");
+      }
+      this.forgetExpansionSnapshot(snapshot);
+      return {
+        session: ref.file,
+        sourceHash: snapshot.sourceHash,
+        branches,
+        lineageFingerprint: snapshot.lineageFingerprint,
+        entryCount,
+        entries: [],
+        next: null
+      };
+    }
+    const requestedSelection = {};
+    if (indices.length > 0) requestedSelection.indices = indices;
+    if (entryIds.length > 0) requestedSelection.entryIds = entryIds;
+    if (operationAddresses.length > 0) requestedSelection.operationAddresses = operationAddresses;
+    if (typeof first === "number" && typeof last === "number") {
+      requestedSelection.entryRange = { first, last };
+    }
+    const requestedWithContext = {
+      ...requestedSelection,
+      ...before > 0 ? { before } : {},
+      ...after > 0 ? { after } : {}
+    };
+    const requestedKey = expansionSelectionKey(requestedWithContext);
+    let resolved = snapshot.selections.get(requestedKey);
+    if (!resolved) {
+      let expansion = expandSessionEntriesChecked(snapshot.entries, requestedSelection);
+      if ("error" in expansion) {
+        return {
+          session: ref.file,
+          sourceHash: snapshot.sourceHash,
+          branches,
+          lineageFingerprint: snapshot.lineageFingerprint,
+          error: expansion.error,
+          entries: []
+        };
+      }
+      let anchorIndex2 = null;
+      let canonical;
+      if (before > 0 || after > 0) {
+        if (expansion.expanded.length !== 1) {
+          throw new Error("memory.expand before/after requires exactly one resolved anchor");
+        }
+        anchorIndex2 = expansion.expanded[0].index;
+        const contextRange = {
+          first: Math.max(0, anchorIndex2 - before),
+          last: Math.min(Math.max(0, entryCount - 1), anchorIndex2 + after)
+        };
+        canonical = requestedWithContext;
+        expansion = expandSessionEntriesChecked(snapshot.entries, { entryRange: contextRange });
+        if ("error" in expansion) {
+          return {
+            session: ref.file,
+            sourceHash: snapshot.sourceHash,
+            branches,
+            lineageFingerprint: snapshot.lineageFingerprint,
+            error: expansion.error,
+            entries: []
+          };
+        }
+      } else if (requestedSelection.entryRange) {
+        canonical = { entryRange: requestedSelection.entryRange };
+      } else {
+        canonical = { indices: expansion.expanded.map((entry) => entry.index) };
+      }
+      resolved = { entries: expansion.expanded, canonical, anchorIndex: anchorIndex2 };
+      this.rememberExpansionSelection(
+        snapshot,
+        [requestedKey, expansionSelectionKey(canonical)],
+        resolved
+      );
+    }
+    const selected = resolved.entries;
+    const canonicalSelection = resolved.canonical;
+    const anchorIndex = resolved.anchorIndex;
+    const finalState = snapshot;
+    const finalLineage = { fingerprint: snapshot.lineageFingerprint };
+    if (entryOffset > selected.length) {
+      return {
+        session: ref.file,
+        error: addressError(`Entry offset ${entryOffset} is outside 0..${selected.length}.`, selected.length),
+        entries: []
+      };
+    }
+    if (entryOffset < selected.length && textOffset > selected[entryOffset].text.length) {
+      return {
+        session: ref.file,
+        error: {
+          code: "text_offset_out_of_bounds",
+          message: `Text offset ${textOffset} exceeds entry #${selected[entryOffset].index} length ${selected[entryOffset].text.length}.`,
+          textLength: selected[entryOffset].text.length
+        },
+        entries: []
+      };
+    }
+    const bounded = (value, maximum = 512) => value === null || value.length <= maximum ? value : `${value.slice(0, Math.max(1, maximum - 1))}\u2026`;
+    const compactStructure = (value) => {
+      if (value === void 0) return void 0;
+      const serialized = JSON.stringify(value);
+      return serialized.length <= 2e3 ? value : void 0;
+    };
+    const output = [];
+    const cursors = [];
+    let position = entryOffset;
+    let currentTextOffset = textOffset;
+    let remainingChars = maxChars;
+    while (position < selected.length && output.length < maxEntries && remainingChars > 0) {
+      const entry = selected[position];
+      let end = Math.min(entry.text.length, currentTextOffset + remainingChars);
+      if (end < entry.text.length && end > currentTextOffset && entry.text.charCodeAt(end) >= 56320 && entry.text.charCodeAt(end) <= 57343) {
+        end -= 1;
+      }
+      if (end === currentTextOffset && currentTextOffset < entry.text.length) {
+        end = Math.min(entry.text.length, currentTextOffset + 2);
+      }
+      const chunk = entry.text.slice(currentTextOffset, end);
+      const textComplete = end >= entry.text.length;
+      const operation = compactStructure(entry.operation);
+      const branchFact = compactStructure(entry.branchFact);
+      output.push({
+        index: entry.index,
+        entryId: bounded(entry.entryId),
+        parentId: bounded(entry.parentId),
+        type: bounded(entry.type),
+        role: bounded(entry.role),
+        timestamp: entry.timestamp,
+        isError: entry.isError,
+        ...anchorIndex !== null ? { anchor: entry.index === anchorIndex } : {},
+        text: chunk,
+        textRange: {
+          start: currentTextOffset,
+          end,
+          total: entry.text.length,
+          complete: textComplete
+        },
+        ...entry.parentEntryId !== void 0 ? { parentEntryId: bounded(entry.parentEntryId) } : {},
+        ...entry.operationAddress ? { operationAddress: bounded(entry.operationAddress) } : {},
+        ...entry.toolName ? { tool: bounded(entry.toolName) } : {},
+        ...entry.ref ? { ref: bounded(entry.ref) } : {},
+        ...entry.provider ? { provider: bounded(entry.provider) } : {},
+        ...entry.action ? { action: bounded(entry.action) } : {},
+        ...entry.outcome ? { outcome: entry.outcome } : {},
+        ...entry.filesTouched ? { filesTouched: entry.filesTouched.slice(0, 20).map((file) => bounded(file, 1024)) } : {},
+        ...operation !== void 0 ? { operation } : {},
+        ...branchFact !== void 0 ? { branchFact } : {},
+        ...entry.operation !== void 0 && operation === void 0 || entry.branchFact !== void 0 && branchFact === void 0 ? { structuredTruncated: true } : {},
+        ...entry.factAddress ? { factAddress: bounded(entry.factAddress) } : {},
+        ...entry.carrierEntryId ? { carrierEntryId: bounded(entry.carrierEntryId) } : {},
+        ...entry.carrierParentId !== void 0 ? { carrierParentId: bounded(entry.carrierParentId) } : {},
+        ...entry.carrierFromId !== void 0 ? { carrierFromId: bounded(entry.carrierFromId) } : {}
+      });
+      remainingChars -= chunk.length;
+      if (!textComplete) {
+        currentTextOffset = end;
+        cursors.push({ position, textOffset: currentTextOffset });
+        break;
+      }
+      position += 1;
+      currentTextOffset = 0;
+      cursors.push({ position, textOffset: 0 });
+    }
+    const responseAt = (records, cursor2) => {
+      const hasNext = cursor2.position < selected.length;
+      const nextArgs = hasNext ? {
+        session: ref.file,
+        expectedSourceHash: finalState.sourceHash,
+        expectedLineageFingerprint: finalLineage.fingerprint,
+        branches,
+        ...canonicalSelection,
+        entryOffset: cursor2.position,
+        ...cursor2.textOffset > 0 ? { textOffset: cursor2.textOffset } : {},
+        maxChars,
+        maxEntries
+      } : null;
+      return {
+        session: ref.file,
+        sourceHash: finalState.sourceHash,
+        branches,
+        lineageFingerprint: finalLineage.fingerprint,
+        entryCount,
+        entries: records,
+        next: nextArgs ? { ref: "memory.expand", args: nextArgs } : null
+      };
+    };
+    let cursor = { position, textOffset: currentTextOffset };
+    let response = responseAt(output, cursor);
+    while (output.length > 1 && JSON.stringify(response).length > RECALL_MAX_RESPONSE_CHARS) {
+      output.pop();
+      cursors.pop();
+      cursor = cursors.at(-1) ?? { position: entryOffset, textOffset };
+      response = responseAt(output, cursor);
+    }
+    if (output.length === 1 && JSON.stringify(response).length > RECALL_MAX_RESPONSE_CHARS) {
+      const record = output[0];
+      const range = record.textRange;
+      const chunk = record.text;
+      const excess = JSON.stringify(response).length - RECALL_MAX_RESPONSE_CHARS;
+      let keep = Math.max(1, chunk.length - excess - 256);
+      if (keep < chunk.length && keep > 0 && chunk.charCodeAt(keep) >= 56320 && chunk.charCodeAt(keep) <= 57343) {
+        keep -= 1;
+      }
+      if (keep > 0 && keep < chunk.length) {
+        record.text = chunk.slice(0, keep);
+        range.end = range.start + keep;
+        range.complete = false;
+        cursor = { position: entryOffset, textOffset: range.end };
+        response = responseAt(output, cursor);
+      }
+      if (JSON.stringify(response).length > RECALL_MAX_RESPONSE_CHARS) {
+        delete record.operation;
+        delete record.branchFact;
+        if (Array.isArray(record.filesTouched)) {
+          record.filesTouched = record.filesTouched.slice(0, 4).map((file) => bounded(String(file), 256));
+        }
+        record.structuredTruncated = true;
+        response = responseAt(output, cursor);
+      }
+      if (JSON.stringify(response).length > RECALL_MAX_RESPONSE_CHARS) {
+        const current = String(record.text);
+        const firstCodePointChars = (current.codePointAt(0) ?? 0) > 65535 ? 2 : 1;
+        const minimalText = current.slice(0, Math.min(current.length, firstCodePointChars));
+        const minimalRange = record.textRange;
+        minimalRange.end = minimalRange.start + minimalText.length;
+        minimalRange.complete = minimalRange.end >= minimalRange.total;
+        output[0] = {
+          index: record.index,
+          entryId: record.entryId,
+          parentId: record.parentId,
+          type: record.type,
+          role: record.role,
+          timestamp: record.timestamp,
+          isError: record.isError,
+          ...record.anchor !== void 0 ? { anchor: record.anchor } : {},
+          text: minimalText,
+          textRange: minimalRange,
+          structuredTruncated: true
+        };
+        cursor = minimalRange.complete ? { position: entryOffset + 1, textOffset: 0 } : { position: entryOffset, textOffset: minimalRange.end };
+        response = responseAt(output, cursor);
+      }
+    }
+    const endingLiveBranch = branches === "active" ? liveResolver?.(ref.file) : void 0;
+    const endingObservation = observeSource(ref.file, branches, endingLiveBranch);
+    if (!endingObservation || !sameSourceObservation(snapshot.observation, endingObservation)) {
+      this.forgetExpansionSnapshot(snapshot);
+      const actualState = fingerprintSource(ref.file);
+      const actualLineage = reconstructSessionLineage(ref.file, branches, endingLiveBranch);
+      if (!actualState || !endingObservation || actualState.sourceHash !== snapshot.sourceHash || actualLineage.fingerprint !== snapshot.lineageFingerprint) {
+        return {
+          session: ref.file,
+          error: stalePointerError(
+            ref.file,
+            expectedSourceHash ?? snapshot.sourceHash,
+            actualState?.sourceHash ?? "",
+            expectedLineageFingerprint ?? snapshot.lineageFingerprint,
+            actualLineage.fingerprint
+          ),
+          entries: []
+        };
+      }
+      snapshot.observation = endingObservation;
+    }
+    if (response.next === null) {
+      this.forgetExpansionSnapshot(snapshot);
+    } else {
+      snapshot.touchedAt = Date.now();
+      this.rememberExpansionSnapshot(snapshot);
+    }
+    return response;
+  }
+  async sessions(args) {
+    const scope = typeof args.scope === "string" ? args.scope : void 0;
+    const branches = parseBranches(args.branches, "memory.sessions");
+    const limit = typeof args.limit === "number" && Number.isSafeInteger(args.limit) && args.limit >= 1 ? Math.min(args.limit, SESSIONS_MAX) : SESSIONS_MAX;
+    const refs = resolveRefs(scope, this.context, true).slice(0, limit);
+    const options = resolveIndexOptions(
+      this.context.config,
+      this.context.agentDir,
+      branches,
+      liveBranchResolver(this.context)
+    );
+    const index = loadTieredIndex(refs, resolveTierRefs(refs, this.context), options);
+    const shards = new Map(index.shards.map((shard) => [shard.sessionFile, shard]));
+    const digests = new Map(index.digests.map((digest) => [digest.file, digest]));
+    const sessions = refs.map((ref) => {
+      const tier = index.tiers.get(ref.file) ?? "cold";
+      const shard = shards.get(ref.file);
+      const digest = digests.get(ref.file);
+      return {
+        id: shard?.sessionId ?? digest?.sessionId ?? ref.id,
+        file: ref.file,
+        cwd: digest?.cwd ?? ref.cwd,
+        mtime: ref.mtime,
+        entryCount: shard?.entries.length ?? digest?.entryCount ?? 0,
+        tier,
+        branches,
+        lineageFingerprint: shard?.lineageFingerprint ?? digest?.lineageFingerprint ?? null
+      };
+    });
+    return { scope: scope ?? "session", branches, sessions };
+  }
+};
+
+export {
+  uniqueDeclaredKeyForSpelling,
+  actionArgNormalizer,
+  normalizeMemoryArgs,
+  MemoryProvider
+};
+//# sourceMappingURL=chunk-T6OAX4FO.js.map