@graphrefly/ts 0.0.0

package/dist/solutions/index.cjs

@@ -0,0 +1,3249 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solutions/index.ts
+var solutions_exports = {};
+__export(solutions_exports, {
+  AGENTIC_MEMORY_RECORD_FRAME_FORMAT: () => AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+  AGENTIC_MEMORY_RECORD_FRAME_VERSION: () => AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+  agenticMemoryBundle: () => agenticMemoryBundle,
+  agenticMemoryConsolidationBundle: () => agenticMemoryConsolidationBundle,
+  agenticMemoryContextPackingBundle: () => agenticMemoryContextPackingBundle,
+  agenticMemoryKgProjectionBundle: () => agenticMemoryKgProjectionBundle,
+  agenticMemoryRecordCodec: () => agenticMemoryRecordCodec,
+  agenticMemoryRecordFrame: () => agenticMemoryRecordFrame,
+  agenticMemoryRecordFrameCodec: () => agenticMemoryRecordFrameCodec,
+  agenticMemoryRetentionBundle: () => agenticMemoryRetentionBundle,
+  assertAgenticMemoryRecordFrame: () => assertAgenticMemoryRecordFrame
+});
+module.exports = __toCommonJS(solutions_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+function depLatest(ctx, depIndex) {
+  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+
+// src/patterns/semantic-memory.ts
+function cosineSimilarity(a, b) {
+  const n = Math.max(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  const score = dot / Math.sqrt(na * nb);
+  return Number.isFinite(score) ? score : 0;
+}
+function memoryFragmentValidAt(fragment, asOf) {
+  if (asOf === void 0) return fragment.validTo === void 0 && fragment.validFrom === void 0;
+  if (fragment.validFrom !== void 0 && fragment.validFrom > asOf) return false;
+  if (fragment.validTo !== void 0 && fragment.validTo <= asOf) return false;
+  return true;
+}
+function memoryFragmentMatchesQuery(fragment, query = {}) {
+  if (!memoryFragmentValidAt(fragment, query.asOf)) return false;
+  if (query.minConfidence !== void 0 && fragment.confidence < query.minConfidence) return false;
+  if (query.tags && query.tags.length > 0 && !query.tags.some((tag) => fragment.tags.includes(tag))) {
+    return false;
+  }
+  return true;
+}
+function filterMemoryFragments(fragments, query = {}) {
+  const results = [...fragments].filter((fragment) => memoryFragmentMatchesQuery(fragment, query));
+  results.sort((a, b) => b.confidence - a.confidence || compareBigIntDesc(a.tNs, b.tNs));
+  return query.limit === void 0 ? results : results.slice(0, Math.max(0, query.limit));
+}
+function validateMemoryFragment(value) {
+  const errors = [];
+  if (typeof value !== "object" || value === null) {
+    return { ok: false, errors: ["fragment must be an object"] };
+  }
+  const fragment = value;
+  if (typeof fragment.id !== "string" || fragment.id.length === 0) {
+    errors.push("id must be a non-empty string");
+  }
+  if (!Object.hasOwn(fragment, "payload")) {
+    errors.push("payload must be present");
+  }
+  if (typeof fragment.tNs !== "bigint") {
+    errors.push("tNs must be a bigint");
+  }
+  const confidence = fragment.confidence;
+  if (!Number.isFinite(confidence) || confidence === void 0 || confidence < 0 || confidence > 1) {
+    errors.push("confidence must be a finite number in [0, 1]");
+  }
+  if (!isDenseArrayOf(fragment.tags, (tag) => typeof tag === "string")) {
+    errors.push("tags must be a readonly string array");
+  }
+  if (!isDenseArrayOf(fragment.sources, (source) => typeof source === "string")) {
+    errors.push("sources must be a readonly string array");
+  }
+  if (fragment.validFrom !== void 0 && typeof fragment.validFrom !== "bigint") {
+    errors.push("validFrom must be a bigint when present");
+  }
+  if (fragment.validTo !== void 0 && typeof fragment.validTo !== "bigint") {
+    errors.push("validTo must be a bigint when present");
+  }
+  if (typeof fragment.validFrom === "bigint" && typeof fragment.validTo === "bigint" && fragment.validFrom >= fragment.validTo) {
+    errors.push("validFrom must be earlier than validTo");
+  }
+  if (fragment.embedding !== void 0 && !isDenseArrayOf(
+    fragment.embedding,
+    (component) => Number.isFinite(component)
+  )) {
+    errors.push("embedding must be a finite number array when present");
+  }
+  if (fragment.parentFragmentId !== void 0 && typeof fragment.parentFragmentId !== "string") {
+    errors.push("parentFragmentId must be a string when present");
+  }
+  if (fragment.provenance !== void 0 && typeof fragment.provenance !== "string") {
+    errors.push("provenance must be a string when present");
+  }
+  return { ok: errors.length === 0, errors };
+}
+function compareBigIntDesc(a, b) {
+  if (a === b) return 0;
+  return a > b ? -1 : 1;
+}
+function isDenseArrayOf(value, predicate) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+  }
+  return true;
+}
+
+// src/patterns/semantic-memory-graph.ts
+function memoryRetrievalBundle(graph, opts) {
+  const name = opts.name ?? "memoryRetrieval";
+  const { fragments, query } = opts;
+  const snapshot = graph.node(
+    [fragments, query],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const rawFragments = depLatest(ctx, 0);
+      const rawQuery = depLatest(ctx, 1);
+      const queryValidation = validateMemoryRetrievalQuery(rawQuery);
+      const currentQuery = queryValidation.query;
+      const valid = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      const errors = [...queryValidation.errors];
+      if (!Array.isArray(rawFragments)) {
+        errors.push({
+          code: "invalid-fragments-input",
+          message: "memoryRetrievalBundle: fragments input must be an array",
+          fragment: rawFragments
+        });
+      } else {
+        const length = safeArrayLength(rawFragments);
+        if (length === void 0) {
+          errors.push({
+            code: "invalid-fragments-input",
+            message: "memoryRetrievalBundle: fragments input length could not be read",
+            fragment: rawFragments
+          });
+        }
+        for (let i = 0; i < (length ?? 0); i += 1) {
+          const result = validateAndSnapshotFragment(rawFragments, i);
+          if (result.error !== void 0) {
+            errors.push(result.error);
+            continue;
+          }
+          const fragment = result.fragment;
+          if (seenIds.has(fragment.id)) {
+            errors.push({
+              code: "duplicate-fragment-id",
+              message: "memoryRetrievalBundle: duplicate fragment id",
+              index: i,
+              fragment,
+              validationErrors: [`duplicate fragment id '${fragment.id}'`]
+            });
+            continue;
+          }
+          seenIds.add(fragment.id);
+          valid.push(fragment);
+        }
+      }
+      const ranked = errors.some((error) => !isRecoverableFragmentError(error)) ? [] : rankFragments(valid, currentQuery);
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validFragments: valid.length,
+        invalidFragments: errors.filter(
+          (error) => error.code === "invalid-fragment" || error.code === "duplicate-fragment-id"
+        ).length,
+        resultCount: ranked.length
+      });
+      ctx.state.set(state);
+      const answer = Object.freeze({
+        query: currentQuery,
+        results: Object.freeze(ranked)
+      });
+      const status = Object.freeze({
+        state: statusState(errors, ranked.length),
+        query: currentQuery,
+        cursor
+      });
+      const indexed = Object.freeze({
+        ids: Object.freeze(valid.map((fragment) => fragment.id)),
+        byId: indexById(valid),
+        cursor
+      });
+      const errorFacts = Object.freeze(
+        errors.map(
+          (error) => Object.freeze({
+            ...error,
+            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
+            cursor
+          })
+        )
+      );
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            fragments: Object.freeze([...valid]),
+            indexed,
+            ranked: answer,
+            status,
+            errors: errorFacts,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/snapshot`,
+      factory: "memoryRetrievalSnapshot",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { fragments, query },
+    snapshot,
+    fragments: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/fragments`,
+      "memoryRetrievalFragments",
+      (fact) => fact.fragments
+    ),
+    indexed: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/indexed`,
+      "memoryRetrievalIndexed",
+      (fact) => fact.indexed
+    ),
+    ranked: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/ranked`,
+      "memoryRetrievalRanked",
+      (fact) => fact.ranked
+    ),
+    status: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/status`,
+      "memoryRetrievalStatus",
+      (fact) => fact.status
+    ),
+    errors: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/errors`,
+      "memoryRetrievalErrors",
+      (fact) => fact.errors
+    ),
+    cursor: retrievalProjection(
+      graph,
+      snapshot,
+      `${name}/cursor`,
+      "memoryRetrievalCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function retrievalProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const fact = raw;
+        const selected = select(fact);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function rankFragments(fragments, query) {
+  if (query.vector === void 0) return filterMemoryFragments(fragments, query);
+  const ranked = fragments.filter((fragment) => memoryFragmentMatchesQuery(fragment, query));
+  ranked.sort((a, b) => {
+    const vectorDelta = vectorScore(b, query) - vectorScore(a, query);
+    if (vectorDelta !== 0) return vectorDelta;
+    const confidenceDelta = b.confidence - a.confidence;
+    if (confidenceDelta !== 0) return confidenceDelta;
+    return compareBigIntDesc2(a.tNs, b.tNs);
+  });
+  return query.limit === void 0 ? ranked : ranked.slice(0, Math.max(0, query.limit));
+}
+function vectorScore(fragment, query) {
+  if (query.vector === void 0 || fragment.embedding === void 0) return 0;
+  return cosineSimilarity(query.vector, fragment.embedding);
+}
+function statusState(errors, resultCount) {
+  if (errors.some((error) => !isRecoverableFragmentError(error))) return "error";
+  if (errors.length > 0) return "partial";
+  return resultCount > 0 ? "ready" : "empty";
+}
+function isRecoverableFragmentError(error) {
+  return error.code === "invalid-fragment" || error.code === "duplicate-fragment-id";
+}
+function indexById(fragments) {
+  const byId = /* @__PURE__ */ Object.create(null);
+  for (const fragment of fragments) byId[fragment.id] = fragment;
+  return Object.freeze(byId);
+}
+function isFiniteVector(value) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i) || !Number.isFinite(value[i])) return false;
+  }
+  return true;
+}
+function validateMemoryRetrievalQuery(value) {
+  try {
+    return validateMemoryRetrievalQueryInner(value);
+  } catch (error) {
+    return {
+      ok: false,
+      query: {},
+      errors: [
+        {
+          code: "invalid-query",
+          message: `memoryRetrievalBundle: query access failed: ${errorMessage(error)}`,
+          fragment: value
+        }
+      ]
+    };
+  }
+}
+function validateMemoryRetrievalQueryInner(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return invalidQuery(value, "memoryRetrievalBundle: query must be an object");
+  }
+  const query = value;
+  const errors = [];
+  if (query.tags !== void 0 && !isDenseArrayOf2(query.tags, (tag) => typeof tag === "string")) {
+    errors.push({
+      code: "invalid-query",
+      message: "memoryRetrievalBundle: query.tags must be a readonly string array",
+      fragment: value,
+      validationErrors: ["tags must be a readonly string array"]
+    });
+  }
+  if (query.asOf !== void 0 && typeof query.asOf !== "bigint") {
+    errors.push({
+      code: "invalid-query",
+      message: "memoryRetrievalBundle: query.asOf must be a bigint",
+      fragment: value,
+      validationErrors: ["asOf must be a bigint when present"]
+    });
+  }
+  if (query.minConfidence !== void 0 && (!Number.isFinite(query.minConfidence) || query.minConfidence < 0 || query.minConfidence > 1)) {
+    errors.push({
+      code: "invalid-query",
+      message: "memoryRetrievalBundle: query.minConfidence must be a finite number in [0, 1]",
+      fragment: value,
+      validationErrors: ["minConfidence must be a finite number in [0, 1]"]
+    });
+  }
+  if (query.limit !== void 0 && (!Number.isSafeInteger(query.limit) || query.limit < 0)) {
+    errors.push({
+      code: "invalid-query",
+      message: "memoryRetrievalBundle: query.limit must be a non-negative safe integer",
+      fragment: value,
+      validationErrors: ["limit must be a non-negative safe integer"]
+    });
+  }
+  if (query.vector !== void 0 && !isFiniteVector(query.vector)) {
+    errors.push({
+      code: "invalid-query-vector",
+      message: "memoryRetrievalBundle: query.vector must be a finite number array",
+      fragment: value,
+      validationErrors: ["vector must be a finite number array"]
+    });
+  }
+  if (errors.length > 0) return { ok: false, query: {}, errors };
+  return { ok: true, query: snapshotQuery(query), errors };
+}
+function invalidQuery(value, message) {
+  return {
+    ok: false,
+    query: {},
+    errors: [
+      {
+        code: "invalid-query",
+        message,
+        fragment: value
+      }
+    ]
+  };
+}
+function snapshotQuery(query) {
+  return Object.freeze({
+    ...query.tags === void 0 ? {} : { tags: Object.freeze([...query.tags]) },
+    ...query.asOf === void 0 ? {} : { asOf: query.asOf },
+    ...query.minConfidence === void 0 ? {} : { minConfidence: query.minConfidence },
+    ...query.limit === void 0 ? {} : { limit: query.limit },
+    ...query.vector === void 0 ? {} : { vector: Object.freeze([...query.vector]) }
+  });
+}
+function safeArrayLength(value) {
+  try {
+    return value.length;
+  } catch {
+    return void 0;
+  }
+}
+function validateAndSnapshotFragment(rawFragments, index) {
+  let raw;
+  try {
+    raw = rawFragments[index];
+    const validation = validateMemoryFragment(raw);
+    if (!validation.ok) {
+      return {
+        error: {
+          code: "invalid-fragment",
+          message: "memoryRetrievalBundle: invalid memory fragment",
+          index,
+          fragment: raw,
+          validationErrors: Object.freeze([...validation.errors])
+        }
+      };
+    }
+    return { fragment: snapshotFragment(raw) };
+  } catch (error) {
+    return {
+      error: {
+        code: "invalid-fragment",
+        message: `memoryRetrievalBundle: fragment access failed: ${errorMessage(error)}`,
+        index,
+        fragment: raw,
+        validationErrors: Object.freeze(["fragment access failed"])
+      }
+    };
+  }
+}
+function snapshotFragment(fragment) {
+  return Object.freeze({
+    id: fragment.id,
+    payload: fragment.payload,
+    tNs: fragment.tNs,
+    ...fragment.validFrom === void 0 ? {} : { validFrom: fragment.validFrom },
+    ...fragment.validTo === void 0 ? {} : { validTo: fragment.validTo },
+    confidence: fragment.confidence,
+    tags: Object.freeze([...fragment.tags]),
+    sources: Object.freeze([...fragment.sources]),
+    ...fragment.embedding === void 0 ? {} : { embedding: Object.freeze([...fragment.embedding]) },
+    ...fragment.parentFragmentId === void 0 ? {} : { parentFragmentId: fragment.parentFragmentId },
+    ...fragment.provenance === void 0 ? {} : { provenance: fragment.provenance }
+  });
+}
+function isDenseArrayOf2(value, predicate) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+  }
+  return true;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function compareBigIntDesc2(a, b) {
+  if (a === b) return 0;
+  return a > b ? -1 : 1;
+}
+
+// src/solutions/agentic-memory.ts
+var AGENTIC_MEMORY_RECORD_FRAME_FORMAT = "graphrefly.agenticMemoryRecord";
+var AGENTIC_MEMORY_RECORD_FRAME_VERSION = 1;
+function agenticMemoryBundle(graph, opts) {
+  const name = opts.name ?? "agenticMemory";
+  const projection = agenticMemoryRecordProjection(graph, opts.records, `${name}/projection`);
+  const projectedRecords = agenticMemoryProjection(
+    graph,
+    projection,
+    `${name}/records`,
+    "agenticMemoryRecords",
+    (fact) => fact.records
+  );
+  const projectedFragments = agenticMemoryProjection(
+    graph,
+    projection,
+    `${name}/fragments`,
+    "agenticMemoryFragments",
+    (fact) => fact.fragments
+  );
+  const status = agenticMemoryProjection(
+    graph,
+    projection,
+    `${name}/status`,
+    "agenticMemoryStatus",
+    (fact) => fact.status
+  );
+  const errors = agenticMemoryProjection(
+    graph,
+    projection,
+    `${name}/errors`,
+    "agenticMemoryErrors",
+    (fact) => fact.errors
+  );
+  const retrieval = memoryRetrievalBundle(graph, {
+    name: `${name}/retrieval`,
+    fragments: projectedFragments,
+    query: opts.query
+  });
+  const sources = agenticMemoryProjection(
+    graph,
+    projection,
+    `${name}/sources`,
+    "agenticMemorySources",
+    (fact) => Object.freeze(
+      fact.fragments.map(
+        (fragment) => Object.freeze({
+          fragmentId: fragment.id,
+          ...fact.metadataByFragmentId[fragment.id] === void 0 ? {} : { record: fact.metadataByFragmentId[fragment.id] },
+          sources: Object.freeze([...fragment.sources]),
+          ...fragment.parentFragmentId === void 0 ? {} : { parentFragmentId: fragment.parentFragmentId },
+          ...fragment.provenance === void 0 ? {} : { provenance: fragment.provenance }
+        })
+      )
+    )
+  );
+  const context = agenticMemoryContextProjection(
+    graph,
+    projection,
+    retrieval.snapshot,
+    `${name}/context`
+  );
+  return {
+    input: { records: opts.records, query: opts.query },
+    projection,
+    retrieval,
+    retrievalSnapshot: retrieval.snapshot,
+    records: projectedRecords,
+    fragments: projectedFragments,
+    sources,
+    indexed: retrieval.indexed,
+    ranked: retrieval.ranked,
+    context,
+    status,
+    errors,
+    retrievalStatus: retrieval.status,
+    retrievalErrors: retrieval.errors,
+    cursor: retrieval.cursor
+  };
+}
+function agenticMemoryKgProjectionBundle(graph, opts) {
+  const name = opts.name ?? "agenticMemoryKgProjection";
+  const projection = graph.node(
+    [opts.records, opts.drafts],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const recordProjection = validateAndProjectRecords(depLatest(ctx, 0));
+      const draftProjection = validateAndProjectKgDrafts(
+        depLatest(ctx, 1),
+        recordProjection.records
+      );
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validRecords: recordProjection.records.length,
+        validDrafts: draftProjection.assertions.length,
+        invalidDrafts: draftProjection.invalidDrafts,
+        projectedAssertions: draftProjection.assertions.length
+      });
+      const errors = Object.freeze(
+        [...recordProjection.errors.map(kgErrorFromRecordError), ...draftProjection.errors].map(
+          (error) => freezeError({ ...error, cursor })
+        )
+      );
+      const status = Object.freeze({
+        state: agenticStatusState(errors.length, draftProjection.assertions.length),
+        cursor
+      });
+      ctx.state.set(state);
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            assertions: Object.freeze(draftProjection.assertions),
+            status,
+            errors,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/projection`,
+      factory: "agenticMemoryKgProjection",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { records: opts.records, drafts: opts.drafts },
+    projection,
+    assertions: solutionProjection(
+      graph,
+      projection,
+      `${name}/assertions`,
+      "agenticMemoryKgAssertions",
+      (fact) => fact.assertions
+    ),
+    status: solutionProjection(
+      graph,
+      projection,
+      `${name}/status`,
+      "agenticMemoryKgStatus",
+      (fact) => fact.status
+    ),
+    errors: solutionProjection(
+      graph,
+      projection,
+      `${name}/errors`,
+      "agenticMemoryKgErrors",
+      (fact) => fact.errors
+    ),
+    cursor: solutionProjection(
+      graph,
+      projection,
+      `${name}/cursor`,
+      "agenticMemoryKgCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function agenticMemoryRecordFrame(record) {
+  const result = validateAndSnapshotRecord(record, 0);
+  if (result.errors.length > 0 || result.record === void 0) {
+    throw new TypeError(
+      `agenticMemoryRecordFrame: invalid record: ${result.errors.flatMap((error) => error.validationErrors ?? [error.message]).join("; ")}`
+    );
+  }
+  assertAgenticMemoryRecordCodecShape(record);
+  assertStrictJsonValue(result.record.fragment.payload, "record.fragment.payload");
+  return Object.freeze({
+    format: AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+    version: AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+    record: Object.freeze({
+      id: result.record.id,
+      kind: result.record.kind,
+      persistenceLevel: result.record.persistenceLevel,
+      artifactKind: result.record.artifactKind,
+      ...result.record.scope === void 0 ? {} : { scope: result.record.scope },
+      fragment: fragmentFrame(result.record.fragment)
+    })
+  });
+}
+function assertAgenticMemoryRecordFrame(value) {
+  if (!isPlainRecord(value))
+    throw new TypeError("agenticMemoryRecordFrame: frame must be an object");
+  assertStrictJsonValue(value, "agenticMemoryRecordFrame");
+  assertExactKeys(value, ["format", "record", "version"], "agenticMemoryRecordFrame");
+  if (value.format !== AGENTIC_MEMORY_RECORD_FRAME_FORMAT) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid format");
+  }
+  if (value.version !== AGENTIC_MEMORY_RECORD_FRAME_VERSION) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid version");
+  }
+  const rawRecord = value.record;
+  if (!isPlainRecord(rawRecord)) {
+    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+  }
+  assertExactKeys(
+    rawRecord,
+    rawRecord.scope === void 0 ? ["artifactKind", "fragment", "id", "kind", "persistenceLevel"] : ["artifactKind", "fragment", "id", "kind", "persistenceLevel", "scope"],
+    "agenticMemoryRecordFrame.record"
+  );
+  const rawFragment = rawRecord.fragment;
+  if (!isPlainRecord(rawFragment)) {
+    throw new TypeError("agenticMemoryRecordFrame: fragment must be an object");
+  }
+  assertExactKeys(
+    rawFragment,
+    [
+      "id",
+      "payload",
+      "tNs",
+      ...rawFragment.validFrom === void 0 ? [] : ["validFrom"],
+      ...rawFragment.validTo === void 0 ? [] : ["validTo"],
+      "confidence",
+      "tags",
+      "sources",
+      ...rawFragment.embedding === void 0 ? [] : ["embedding"],
+      ...rawFragment.parentFragmentId === void 0 ? [] : ["parentFragmentId"],
+      ...rawFragment.provenance === void 0 ? [] : ["provenance"]
+    ],
+    "agenticMemoryRecordFrame.record.fragment"
+  );
+  if (rawRecord.scope !== void 0) assertScopeFrame(rawRecord.scope);
+  const frame = value;
+  const decoded = recordFromFrame(frame);
+  const roundtrip = agenticMemoryRecordFrame(decoded);
+  return roundtrip;
+}
+function agenticMemoryRecordFrameCodec() {
+  return {
+    encode(value) {
+      return strictJsonCodec.encode(assertAgenticMemoryRecordFrame(value));
+    },
+    decode(bytes) {
+      return assertAgenticMemoryRecordFrame(strictJsonCodec.decode(bytes));
+    }
+  };
+}
+function agenticMemoryRecordCodec() {
+  const frameCodec = agenticMemoryRecordFrameCodec();
+  return {
+    encode(value) {
+      return frameCodec.encode(agenticMemoryRecordFrame(value));
+    },
+    decode(bytes) {
+      return recordFromFrame(frameCodec.decode(bytes));
+    }
+  };
+}
+function agenticMemoryRetentionBundle(graph, opts) {
+  const name = opts.name ?? "agenticMemoryRetention";
+  const projection = graph.node(
+    [opts.records, opts.commands],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const recordProjection = validateAndProjectRecords(depLatest(ctx, 0));
+      const retention = projectRetention(depLatest(ctx, 1), recordProjection.records);
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validRecords: recordProjection.records.length,
+        validCommands: retention.validCommands,
+        invalidCommands: retention.invalidCommands,
+        activeRecords: retention.activeRecords.length,
+        archivedRecords: retention.archivedRecords.length,
+        consolidationRequests: retention.consolidationRequests.length
+      });
+      const errors = Object.freeze(
+        [...recordProjection.errors.map(retentionErrorFromRecordError), ...retention.errors].map(
+          (error) => freezeError({ ...error, cursor })
+        )
+      );
+      const status = Object.freeze({
+        state: agenticStatusState(errors.length, recordProjection.records.length),
+        cursor
+      });
+      ctx.state.set(state);
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            activeRecords: Object.freeze(retention.activeRecords),
+            archivedRecords: Object.freeze(retention.archivedRecords),
+            consolidationRequests: Object.freeze(retention.consolidationRequests),
+            status,
+            errors,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/projection`,
+      factory: "agenticMemoryRetention",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { records: opts.records, commands: opts.commands },
+    projection,
+    activeRecords: solutionProjection(
+      graph,
+      projection,
+      `${name}/activeRecords`,
+      "agenticMemoryRetentionActiveRecords",
+      (fact) => fact.activeRecords
+    ),
+    archivedRecords: solutionProjection(
+      graph,
+      projection,
+      `${name}/archivedRecords`,
+      "agenticMemoryRetentionArchivedRecords",
+      (fact) => fact.archivedRecords
+    ),
+    consolidationRequests: solutionProjection(
+      graph,
+      projection,
+      `${name}/consolidationRequests`,
+      "agenticMemoryRetentionConsolidationRequests",
+      (fact) => fact.consolidationRequests
+    ),
+    status: solutionProjection(
+      graph,
+      projection,
+      `${name}/status`,
+      "agenticMemoryRetentionStatus",
+      (fact) => fact.status
+    ),
+    errors: solutionProjection(
+      graph,
+      projection,
+      `${name}/errors`,
+      "agenticMemoryRetentionErrors",
+      (fact) => fact.errors
+    ),
+    cursor: solutionProjection(
+      graph,
+      projection,
+      `${name}/cursor`,
+      "agenticMemoryRetentionCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function agenticMemoryConsolidationBundle(graph, opts) {
+  const name = opts.name ?? "agenticMemoryConsolidation";
+  const projection = graph.node(
+    [opts.records, opts.requests, opts.outcomes],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const recordProjection = validateAndProjectRecords(depLatest(ctx, 0));
+      const requests = validateConsolidationRequests(depLatest(ctx, 1), recordProjection.records);
+      const outcomes = projectConsolidationOutcomes(
+        depLatest(ctx, 2),
+        requests.requests,
+        state.evaluation
+      );
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validRequests: requests.requests.length,
+        validOutcomes: outcomes.validOutcomes,
+        invalidOutcomes: outcomes.invalidOutcomes,
+        results: outcomes.results.length,
+        proposedRecordDrafts: outcomes.proposedRecordDrafts.length
+      });
+      const errors = Object.freeze(
+        [
+          ...recordProjection.errors.map(consolidationErrorFromRecordError),
+          ...requests.errors.map(consolidationErrorFromRetentionError),
+          ...outcomes.errors
+        ].map((error) => freezeError({ ...error, cursor }))
+      );
+      const status = Object.freeze({
+        state: agenticStatusState(errors.length, outcomes.results.length),
+        cursor
+      });
+      ctx.state.set(state);
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            results: Object.freeze(outcomes.results),
+            proposedRecordDrafts: Object.freeze(outcomes.proposedRecordDrafts),
+            commands: Object.freeze(outcomes.commands),
+            status,
+            errors,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name: `${name}/projection`,
+      factory: "agenticMemoryConsolidation",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { records: opts.records, requests: opts.requests, outcomes: opts.outcomes },
+    projection,
+    results: solutionProjection(
+      graph,
+      projection,
+      `${name}/results`,
+      "agenticMemoryConsolidationResults",
+      (fact) => fact.results
+    ),
+    proposedRecordDrafts: solutionProjection(
+      graph,
+      projection,
+      `${name}/proposedRecordDrafts`,
+      "agenticMemoryConsolidationRecordDrafts",
+      (fact) => fact.proposedRecordDrafts
+    ),
+    commands: solutionProjection(
+      graph,
+      projection,
+      `${name}/commands`,
+      "agenticMemoryConsolidationCommands",
+      (fact) => fact.commands
+    ),
+    status: solutionProjection(
+      graph,
+      projection,
+      `${name}/status`,
+      "agenticMemoryConsolidationStatus",
+      (fact) => fact.status
+    ),
+    errors: solutionProjection(
+      graph,
+      projection,
+      `${name}/errors`,
+      "agenticMemoryConsolidationErrors",
+      (fact) => fact.errors
+    ),
+    cursor: solutionProjection(
+      graph,
+      projection,
+      `${name}/cursor`,
+      "agenticMemoryConsolidationCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function agenticMemoryContextPackingBundle(graph, opts) {
+  const name = opts.name ?? "agenticMemoryContextPacking";
+  const projection = graph.node(
+    [opts.context, opts.texts, opts.policy],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const packed = packContext(
+        depLatest(ctx, 0),
+        depLatest(ctx, 1),
+        depLatest(ctx, 2),
+        state.evaluation
+      );
+      ctx.state.set(state);
+      ctx.down([["DATA", packed]]);
+    },
+    {
+      name: `${name}/projection`,
+      factory: "agenticMemoryContextPacking",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    input: { context: opts.context, texts: opts.texts, policy: opts.policy },
+    projection,
+    packedContext: solutionProjection(
+      graph,
+      projection,
+      `${name}/packedContext`,
+      "agenticMemoryPackedContext",
+      (fact) => fact.packedContext
+    ),
+    status: solutionProjection(
+      graph,
+      projection,
+      `${name}/status`,
+      "agenticMemoryContextPackingStatus",
+      (fact) => fact.status
+    ),
+    errors: solutionProjection(
+      graph,
+      projection,
+      `${name}/errors`,
+      "agenticMemoryContextPackingErrors",
+      (fact) => fact.errors
+    ),
+    cursor: solutionProjection(
+      graph,
+      projection,
+      `${name}/cursor`,
+      "agenticMemoryContextPackingCursor",
+      (fact) => fact.cursor
+    )
+  };
+}
+function solutionProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", select(raw)]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function agenticMemoryProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", select(raw)]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function agenticMemoryContextProjection(graph, projection, retrieval, name) {
+  return graph.node(
+    [projection, retrieval],
+    (ctx) => {
+      const projectionFact = depLatest(ctx, 0);
+      const retrievalFacts = depBatch(ctx, 1) ?? [];
+      if (projectionFact === void 0 || retrievalFacts.length === 0) return;
+      for (const raw of retrievalFacts) {
+        ctx.down([
+          ["DATA", contextFromSnapshot(projectionFact, raw)]
+        ]);
+      }
+    },
+    {
+      name,
+      factory: "agenticMemoryContext",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function contextFromSnapshot(projection, retrieval) {
+  const entries = retrieval.ranked.results.map(
+    (fragment) => Object.freeze({
+      fragmentId: fragment.id,
+      payload: fragment.payload,
+      confidence: fragment.confidence,
+      tags: fragment.tags,
+      sources: fragment.sources,
+      ...projection.metadataByFragmentId[fragment.id] === void 0 ? {} : { record: projection.metadataByFragmentId[fragment.id] },
+      fragment
+    })
+  );
+  const hasContext = entries.length > 0;
+  const state = contextState(projection.status.state, retrieval.status.state);
+  return Object.freeze({
+    state,
+    query: retrieval.ranked.query,
+    entries: Object.freeze(entries),
+    cursor: retrieval.cursor,
+    errors: projection.errors,
+    retrievalErrors: retrieval.errors,
+    contextReady: hasContext && (state === "ready" || state === "partial")
+  });
+}
+function agenticMemoryRecordProjection(graph, records, name) {
+  return graph.node(
+    [records],
+    (ctx) => {
+      const state = ctx.state.get() ?? { evaluation: 0 };
+      state.evaluation += 1;
+      const rawRecords = (depBatch(ctx, 0) ?? []).at(-1);
+      const projected = validateAndProjectRecords(rawRecords);
+      const cursor = Object.freeze({
+        evaluation: state.evaluation,
+        validRecords: projected.records.length,
+        invalidRecords: projected.invalidRecordIndexes.size,
+        projectedFragments: projected.fragments.length
+      });
+      const status = Object.freeze({
+        state: agenticStatusState(projected.errors.length, projected.records.length),
+        cursor
+      });
+      const errors = Object.freeze(
+        projected.errors.map(
+          (error) => Object.freeze({
+            ...error,
+            ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) },
+            cursor
+          })
+        )
+      );
+      ctx.state.set(state);
+      ctx.down([
+        [
+          "DATA",
+          Object.freeze({
+            records: Object.freeze(projected.records),
+            fragments: Object.freeze(projected.fragments),
+            metadataByFragmentId: Object.freeze(projected.metadataByFragmentId),
+            status,
+            errors,
+            cursor
+          })
+        ]
+      ]);
+    },
+    {
+      name,
+      factory: "agenticMemoryProjection",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function validateAndProjectKgDrafts(value, records) {
+  const assertions = [];
+  const errors = [];
+  let invalidDrafts = 0;
+  if (!Array.isArray(value)) {
+    return {
+      assertions,
+      invalidDrafts: 1,
+      errors: [
+        {
+          code: "invalid-drafts-input",
+          message: "agenticMemoryKgProjectionBundle: drafts input must be an array",
+          draft: value
+        }
+      ]
+    };
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    return {
+      assertions,
+      invalidDrafts: 1,
+      errors: [
+        {
+          code: "invalid-drafts-input",
+          message: "agenticMemoryKgProjectionBundle: drafts input length could not be read",
+          draft: value
+        }
+      ]
+    };
+  }
+  const recordById = new Map(records.map((record) => [record.id, record]));
+  const fragmentToRecord = new Map(records.map((record) => [record.fragment.id, record.id]));
+  const seenAssertions = /* @__PURE__ */ new Set();
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      raw = value[i];
+      const result = validateKgDraft(raw, i);
+      if (result.errors.length > 0 || result.draft === void 0) {
+        invalidDrafts += 1;
+        errors.push(...result.errors);
+        continue;
+      }
+      const draft = result.draft;
+      if (seenAssertions.has(draft.id)) {
+        invalidDrafts += 1;
+        errors.push({
+          code: "duplicate-assertion-id",
+          message: "agenticMemoryKgProjectionBundle: duplicate assertion id",
+          index: i,
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`duplicate assertion id '${draft.id}'`]
+        });
+        continue;
+      }
+      const record = recordById.get(draft.recordId);
+      if (record === void 0) {
+        invalidDrafts += 1;
+        errors.push({
+          code: "missing-record-ref",
+          message: "agenticMemoryKgProjectionBundle: draft references a missing record",
+          index: i,
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`record '${draft.recordId}' is not projected`]
+        });
+        continue;
+      }
+      const owner = fragmentToRecord.get(draft.fragmentId);
+      if (owner === void 0) {
+        invalidDrafts += 1;
+        errors.push({
+          code: "missing-fragment-ref",
+          message: "agenticMemoryKgProjectionBundle: draft references a missing fragment",
+          index: i,
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`fragment '${draft.fragmentId}' is not projected`]
+        });
+        continue;
+      }
+      if (owner !== draft.recordId || record.fragment.id !== draft.fragmentId) {
+        invalidDrafts += 1;
+        errors.push({
+          code: "fragment-record-mismatch",
+          message: "agenticMemoryKgProjectionBundle: draft record and fragment refs disagree",
+          index: i,
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [
+            `fragment '${draft.fragmentId}' belongs to record '${owner}', not '${draft.recordId}'`
+          ]
+        });
+        continue;
+      }
+      seenAssertions.add(draft.id);
+      assertions.push(
+        Object.freeze({
+          id: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          subject: draft.subject,
+          predicate: draft.predicate,
+          object: draft.object,
+          ...draft.confidence === void 0 ? {} : { confidence: draft.confidence },
+          sources: Object.freeze(draft.sources ?? [draft.fragmentId]),
+          ...draft.provenance === void 0 ? {} : { provenance: draft.provenance }
+        })
+      );
+    } catch (error) {
+      invalidDrafts += 1;
+      errors.push({
+        code: "invalid-draft",
+        message: `agenticMemoryKgProjectionBundle: draft access failed: ${errorMessage2(error)}`,
+        index: i,
+        draft: raw,
+        validationErrors: ["draft access failed"]
+      });
+    }
+  }
+  return { assertions, errors, invalidDrafts };
+}
+function validateKgDraft(value, index) {
+  const errors = [];
+  if (!isPlainRecord(value)) {
+    return {
+      errors: [
+        {
+          code: "invalid-draft",
+          message: "agenticMemoryKgProjectionBundle: draft must be an object",
+          index,
+          draft: value
+        }
+      ]
+    };
+  }
+  const raw = value;
+  const id = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : void 0;
+  const recordId = typeof raw.recordId === "string" && raw.recordId.length > 0 ? raw.recordId : void 0;
+  const fragmentId = typeof raw.fragmentId === "string" && raw.fragmentId.length > 0 ? raw.fragmentId : void 0;
+  const subject = validateAssertionSubject(raw.subject);
+  const object = validateAssertionObject(raw.object);
+  const shapeErrors = [];
+  if (id === void 0) shapeErrors.push("draft.id must be a non-empty string");
+  if (recordId === void 0) {
+    shapeErrors.push("draft.recordId must be a non-empty string");
+  }
+  if (fragmentId === void 0) {
+    shapeErrors.push("draft.fragmentId must be a non-empty string");
+  }
+  shapeErrors.push(...subject.errors);
+  if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
+    shapeErrors.push("draft.predicate must be a non-empty string");
+  }
+  shapeErrors.push(...object.errors);
+  if (raw.confidence !== void 0 && (!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)) {
+    shapeErrors.push("draft.confidence must be a finite number in [0, 1]");
+  }
+  if (raw.sources !== void 0 && !isDenseArrayOf3(raw.sources, isNonEmptyString)) {
+    shapeErrors.push("draft.sources must be a readonly string array");
+  }
+  if (raw.provenance !== void 0 && typeof raw.provenance !== "string") {
+    shapeErrors.push("draft.provenance must be a string when present");
+  }
+  if (shapeErrors.length > 0) errors.push(kgShapeError(index, value, ...shapeErrors));
+  if (errors.length > 0 || id === void 0 || recordId === void 0 || fragmentId === void 0) {
+    return { errors };
+  }
+  return {
+    draft: Object.freeze({
+      id,
+      recordId,
+      fragmentId,
+      subject: subject.subject,
+      predicate: raw.predicate,
+      object: object.object,
+      ...raw.confidence === void 0 ? {} : { confidence: raw.confidence },
+      ...raw.sources === void 0 ? {} : { sources: Object.freeze([...raw.sources]) },
+      ...raw.provenance === void 0 ? {} : { provenance: raw.provenance }
+    }),
+    errors
+  };
+}
+function validateAssertionSubject(value) {
+  if (!isPlainRecord(value)) return { errors: ["subject must be an object"] };
+  const id = value.id;
+  const type = value.type;
+  const errors = [];
+  if (typeof id !== "string" || id.length === 0) errors.push("subject.id must be non-empty");
+  if (type !== void 0 && (typeof type !== "string" || type.length === 0)) {
+    errors.push("subject.type must be a non-empty string when present");
+  }
+  if (errors.length > 0) return { errors };
+  return {
+    subject: Object.freeze({
+      id,
+      ...type === void 0 ? {} : { type }
+    }),
+    errors
+  };
+}
+function validateAssertionObject(value) {
+  if (!isPlainRecord(value)) return { errors: ["object must be an object"] };
+  const kind = value.kind;
+  const errors = [];
+  if (kind === "entity") {
+    if (typeof value.id !== "string" || value.id.length === 0) {
+      errors.push("object.id must be non-empty for entity objects");
+    }
+    if (value.type !== void 0 && (typeof value.type !== "string" || value.type.length === 0)) {
+      errors.push("object.type must be a non-empty string when present");
+    }
+    if (Object.hasOwn(value, "value")) errors.push("entity object must not include value");
+    if (errors.length > 0) return { errors };
+    return {
+      object: Object.freeze({
+        kind: "entity",
+        id: value.id,
+        ...value.type === void 0 ? {} : { type: value.type }
+      }),
+      errors
+    };
+  }
+  if (kind === "value") {
+    if (!Object.hasOwn(value, "value")) errors.push("value object must include value");
+    else {
+      try {
+        assertStrictJsonValue(value.value, "object.value");
+      } catch (error) {
+        errors.push(errorMessage2(error));
+      }
+    }
+    if (value.valueType !== void 0 && (typeof value.valueType !== "string" || value.valueType.length === 0)) {
+      errors.push("object.valueType must be a non-empty string when present");
+    }
+    if (Object.hasOwn(value, "id")) errors.push("value object must not include id");
+    if (errors.length > 0) return { errors };
+    return {
+      object: Object.freeze({
+        kind: "value",
+        value: value.value,
+        ...value.valueType === void 0 ? {} : { valueType: value.valueType }
+      }),
+      errors
+    };
+  }
+  return { errors: ["object.kind must be entity or value"] };
+}
+function kgShapeError(index, draft, ...validationErrors) {
+  return {
+    code: "invalid-assertion-shape",
+    message: "agenticMemoryKgProjectionBundle: draft assertion shape is invalid",
+    index,
+    draft,
+    validationErrors: Object.freeze([...validationErrors])
+  };
+}
+function kgErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+function fragmentFrame(fragment) {
+  return Object.freeze({
+    id: fragment.id,
+    payload: fragment.payload,
+    tNs: decimalBigIntString(fragment.tNs, "fragment.tNs"),
+    ...fragment.validFrom === void 0 ? {} : { validFrom: decimalBigIntString(fragment.validFrom, "fragment.validFrom") },
+    ...fragment.validTo === void 0 ? {} : { validTo: decimalBigIntString(fragment.validTo, "fragment.validTo") },
+    confidence: fragment.confidence,
+    tags: Object.freeze([...fragment.tags]),
+    sources: Object.freeze([...fragment.sources]),
+    ...fragment.embedding === void 0 ? {} : { embedding: Object.freeze([...fragment.embedding]) },
+    ...fragment.parentFragmentId === void 0 ? {} : { parentFragmentId: fragment.parentFragmentId },
+    ...fragment.provenance === void 0 ? {} : { provenance: fragment.provenance }
+  });
+}
+function recordFromFrame(frame) {
+  const fragment = frame.record.fragment;
+  const record = {
+    id: assertNonEmptyString(frame.record.id, "record.id"),
+    kind: assertKindValue(frame.record.kind),
+    persistenceLevel: assertPersistenceLevelValue(frame.record.persistenceLevel),
+    artifactKind: assertArtifactKindValue(frame.record.artifactKind),
+    ...frame.record.scope === void 0 ? {} : { scope: assertScopeFrame(frame.record.scope) },
+    fragment: {
+      id: assertNonEmptyString(fragment.id, "fragment.id"),
+      payload: assertStrictJsonValue(fragment.payload, "fragment.payload"),
+      tNs: parseDecimalBigInt(fragment.tNs, "fragment.tNs"),
+      ...fragment.validFrom === void 0 ? {} : { validFrom: parseDecimalBigInt(fragment.validFrom, "fragment.validFrom") },
+      ...fragment.validTo === void 0 ? {} : { validTo: parseDecimalBigInt(fragment.validTo, "fragment.validTo") },
+      confidence: assertConfidence(fragment.confidence, "fragment.confidence"),
+      tags: assertStringArray(fragment.tags, "fragment.tags"),
+      sources: assertStringArray(fragment.sources, "fragment.sources"),
+      ...fragment.embedding === void 0 ? {} : { embedding: assertFiniteNumberArray(fragment.embedding, "fragment.embedding") },
+      ...fragment.parentFragmentId === void 0 ? {} : {
+        parentFragmentId: assertNonEmptyString(fragment.parentFragmentId, "parentFragmentId")
+      },
+      ...fragment.provenance === void 0 ? {} : { provenance: assertString(fragment.provenance, "provenance") }
+    }
+  };
+  const result = validateAndSnapshotRecord(record, 0);
+  if (result.errors.length > 0 || result.record === void 0) {
+    throw new TypeError(
+      `agenticMemoryRecordFrame: decoded record is invalid: ${result.errors.flatMap((error) => error.validationErrors ?? [error.message]).join("; ")}`
+    );
+  }
+  return result.record;
+}
+function projectRetention(value, records) {
+  const byId = new Map(records.map((record) => [record.id, record]));
+  const view = new Map(records.map((record) => [record.id, record]));
+  const requests = [];
+  const errors = [];
+  let validCommands = 0;
+  let invalidCommands = 0;
+  if (!Array.isArray(value)) {
+    return {
+      activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
+      archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
+      consolidationRequests: requests,
+      validCommands,
+      invalidCommands: 1,
+      errors: [
+        {
+          code: "invalid-commands-input",
+          message: "agenticMemoryRetentionBundle: commands input must be an array",
+          command: value
+        }
+      ]
+    };
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    return {
+      activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
+      archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
+      consolidationRequests: requests,
+      validCommands,
+      invalidCommands: 1,
+      errors: [
+        {
+          code: "invalid-commands-input",
+          message: "agenticMemoryRetentionBundle: commands input length could not be read",
+          command: value
+        }
+      ]
+    };
+  }
+  const seenCommands = /* @__PURE__ */ new Set();
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      raw = value[i];
+      const result = validateRetentionCommand(raw, i);
+      if (result.errors.length > 0 || result.command === void 0) {
+        invalidCommands += 1;
+        errors.push(...result.errors);
+        continue;
+      }
+      const command = result.command;
+      if (seenCommands.has(command.id)) {
+        invalidCommands += 1;
+        errors.push({
+          code: "duplicate-command-id",
+          message: "agenticMemoryRetentionBundle: duplicate command id",
+          index: i,
+          commandId: command.id,
+          command: raw,
+          validationErrors: [`duplicate command id '${command.id}'`]
+        });
+        continue;
+      }
+      const missing = retentionMissingRecords(command, byId);
+      if (missing.length > 0) {
+        invalidCommands += 1;
+        errors.push({
+          code: "missing-record-ref",
+          message: "agenticMemoryRetentionBundle: command references missing records",
+          index: i,
+          commandId: command.id,
+          recordId: "recordId" in command ? command.recordId : void 0,
+          recordIds: Object.freeze(missing),
+          command: raw,
+          validationErrors: Object.freeze(missing.map((id) => `record '${id}' is not projected`))
+        });
+        continue;
+      }
+      seenCommands.add(command.id);
+      validCommands += 1;
+      applyRetentionCommand(command, byId, view, requests);
+    } catch (error) {
+      invalidCommands += 1;
+      errors.push({
+        code: "invalid-command",
+        message: `agenticMemoryRetentionBundle: command access failed: ${errorMessage2(error)}`,
+        index: i,
+        command: raw,
+        validationErrors: ["command access failed"]
+      });
+    }
+  }
+  const projected = records.map((record) => view.get(record.id) ?? record);
+  return {
+    activeRecords: projected.filter((record) => record.persistenceLevel !== "archived"),
+    archivedRecords: projected.filter((record) => record.persistenceLevel === "archived"),
+    consolidationRequests: requests,
+    errors,
+    validCommands,
+    invalidCommands
+  };
+}
+function validateRetentionCommand(value, index) {
+  if (!isPlainRecord(value)) {
+    return {
+      errors: [
+        {
+          code: "invalid-command",
+          message: "agenticMemoryRetentionBundle: command must be an object",
+          index,
+          command: value
+        }
+      ]
+    };
+  }
+  const id = typeof value.id === "string" && value.id.length > 0 ? value.id : void 0;
+  const kind = value.kind;
+  const errors = [];
+  if (id === void 0) errors.push("command.id must be a non-empty string");
+  if (kind !== "archive" && kind !== "restore" && kind !== "setPersistenceLevel" && kind !== "requestConsolidation") {
+    errors.push("command.kind is invalid");
+  }
+  if (value.reason !== void 0 && typeof value.reason !== "string") {
+    errors.push("command.reason must be a string when present");
+  }
+  if (kind === "archive") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+  } else if (kind === "restore") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+    if (value.persistenceLevel !== void 0 && (!isAgenticMemoryPersistenceLevel(value.persistenceLevel) || value.persistenceLevel === "archived")) {
+      errors.push("restore.persistenceLevel must be a non-archived persistence level when present");
+    }
+  } else if (kind === "setPersistenceLevel") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+    if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+      errors.push("setPersistenceLevel.persistenceLevel is invalid");
+    }
+  } else if (kind === "requestConsolidation") {
+    if (!isDenseArrayOf3(value.recordIds, isNonEmptyString) || value.recordIds.length === 0) {
+      errors.push("requestConsolidation.recordIds must be a non-empty string array");
+    }
+    if (value.requestId !== void 0 && (typeof value.requestId !== "string" || value.requestId.length === 0)) {
+      errors.push("requestConsolidation.requestId must be non-empty when present");
+    }
+  }
+  if (errors.length > 0 || id === void 0) {
+    return {
+      errors: [
+        {
+          code: "invalid-command",
+          message: "agenticMemoryRetentionBundle: command is invalid",
+          index,
+          commandId: id,
+          command: value,
+          validationErrors: Object.freeze(errors)
+        }
+      ]
+    };
+  }
+  const base = { id, reason: value.reason };
+  if (kind === "archive") {
+    return {
+      command: Object.freeze({
+        ...base,
+        kind,
+        recordId: value.recordId,
+        ...base.reason === void 0 ? {} : { reason: base.reason }
+      }),
+      errors: []
+    };
+  }
+  if (kind === "restore") {
+    return {
+      command: Object.freeze({
+        ...base,
+        kind,
+        recordId: value.recordId,
+        ...value.persistenceLevel === void 0 ? {} : {
+          persistenceLevel: value.persistenceLevel
+        },
+        ...base.reason === void 0 ? {} : { reason: base.reason }
+      }),
+      errors: []
+    };
+  }
+  if (kind === "setPersistenceLevel") {
+    return {
+      command: Object.freeze({
+        ...base,
+        kind,
+        recordId: value.recordId,
+        persistenceLevel: value.persistenceLevel,
+        ...base.reason === void 0 ? {} : { reason: base.reason }
+      }),
+      errors: []
+    };
+  }
+  return {
+    command: Object.freeze({
+      ...base,
+      kind: "requestConsolidation",
+      recordIds: Object.freeze([...value.recordIds]),
+      ...value.requestId === void 0 ? {} : { requestId: value.requestId },
+      ...base.reason === void 0 ? {} : { reason: base.reason }
+    }),
+    errors: []
+  };
+}
+function retentionMissingRecords(command, records) {
+  if ("recordId" in command) return records.has(command.recordId) ? [] : [command.recordId];
+  return command.recordIds.filter((recordId) => !records.has(recordId));
+}
+function applyRetentionCommand(command, source, view, requests) {
+  if (command.kind === "requestConsolidation") {
+    requests.push(
+      Object.freeze({
+        id: command.requestId ?? command.id,
+        commandId: command.id,
+        recordIds: Object.freeze([...command.recordIds]),
+        ...command.reason === void 0 ? {} : { reason: command.reason }
+      })
+    );
+    return;
+  }
+  const record = view.get(command.recordId) ?? source.get(command.recordId);
+  if (record === void 0) return;
+  const persistenceLevel = command.kind === "archive" ? "archived" : command.kind === "restore" ? command.persistenceLevel ?? nonArchivedLevel(source.get(command.recordId) ?? record) : command.persistenceLevel;
+  view.set(command.recordId, withPersistenceLevel(record, persistenceLevel));
+}
+function nonArchivedLevel(record) {
+  return record.persistenceLevel === "archived" ? "session" : record.persistenceLevel;
+}
+function withPersistenceLevel(record, persistenceLevel) {
+  return Object.freeze({
+    ...record,
+    persistenceLevel
+  });
+}
+function retentionErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+function validateConsolidationRequests(value, records) {
+  const byId = new Map(records.map((record) => [record.id, record]));
+  const requests = [];
+  const errors = [];
+  if (!Array.isArray(value)) {
+    return {
+      requests,
+      errors: [
+        {
+          code: "invalid-commands-input",
+          message: "agenticMemoryConsolidationBundle: requests input must be an array",
+          command: value
+        }
+      ]
+    };
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    return {
+      requests,
+      errors: [
+        {
+          code: "invalid-commands-input",
+          message: "agenticMemoryConsolidationBundle: requests input length could not be read",
+          command: value
+        }
+      ]
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      if (!Object.hasOwn(value, i)) {
+        throw new TypeError("request array must be dense");
+      }
+      raw = value[i];
+    } catch (error) {
+      errors.push({
+        code: "invalid-command",
+        message: `agenticMemoryConsolidationBundle: request access failed: ${errorMessage2(error)}`,
+        index: i,
+        validationErrors: Object.freeze(["request access failed"])
+      });
+      continue;
+    }
+    if (!isPlainRecord(raw)) {
+      errors.push({
+        code: "invalid-command",
+        message: "agenticMemoryConsolidationBundle: request must be an object",
+        index: i,
+        command: raw
+      });
+      continue;
+    }
+    const id = isNonEmptyString(raw.id) ? raw.id : void 0;
+    const commandId = isNonEmptyString(raw.commandId) ? raw.commandId : void 0;
+    const recordIds = isDenseArrayOf3(raw.recordIds, isNonEmptyString) ? Object.freeze([...raw.recordIds]) : void 0;
+    const validationErrors = [];
+    if (id === void 0) validationErrors.push("request.id must be a non-empty string");
+    if (commandId === void 0) {
+      validationErrors.push("request.commandId must be a non-empty string");
+    }
+    if (recordIds === void 0 || recordIds.length === 0) {
+      validationErrors.push("request.recordIds must be a non-empty string array");
+    }
+    if (raw.reason !== void 0 && typeof raw.reason !== "string") {
+      validationErrors.push("request.reason must be a string when present");
+    }
+    if (id !== void 0 && seen.has(id)) {
+      validationErrors.push(`duplicate request id '${id}'`);
+    }
+    const missing = (recordIds ?? []).filter((recordId) => !byId.has(recordId));
+    if (missing.length > 0) {
+      errors.push({
+        code: "missing-record-ref",
+        message: "agenticMemoryConsolidationBundle: request references missing records",
+        index: i,
+        commandId,
+        recordIds: Object.freeze(missing),
+        command: raw,
+        validationErrors: Object.freeze(
+          missing.map((recordId) => `record '${recordId}' is not projected`)
+        )
+      });
+      continue;
+    }
+    if (validationErrors.length > 0 || id === void 0 || commandId === void 0 || recordIds === void 0) {
+      errors.push({
+        code: "invalid-command",
+        message: "agenticMemoryConsolidationBundle: request is invalid",
+        index: i,
+        commandId,
+        recordIds,
+        command: raw,
+        validationErrors: Object.freeze(validationErrors)
+      });
+      continue;
+    }
+    seen.add(id);
+    requests.push(
+      Object.freeze({
+        id,
+        commandId,
+        recordIds,
+        ...raw.reason === void 0 ? {} : { reason: raw.reason }
+      })
+    );
+  }
+  return { requests: Object.freeze(requests), errors };
+}
+function projectConsolidationOutcomes(value, requests, evaluation) {
+  const byRequest = new Map(requests.map((request) => [request.id, request]));
+  const results = [];
+  const proposedRecordDrafts = [];
+  const commands = [];
+  const errors = [];
+  let validOutcomes = 0;
+  let invalidOutcomes = 0;
+  if (!Array.isArray(value)) {
+    return {
+      results,
+      proposedRecordDrafts,
+      commands,
+      validOutcomes,
+      invalidOutcomes: 1,
+      errors: [
+        {
+          code: "invalid-outcomes-input",
+          message: "agenticMemoryConsolidationBundle: outcomes input must be an array",
+          outcome: value
+        }
+      ]
+    };
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    return {
+      results,
+      proposedRecordDrafts,
+      commands,
+      validOutcomes,
+      invalidOutcomes: 1,
+      errors: [
+        {
+          code: "invalid-outcomes-input",
+          message: "agenticMemoryConsolidationBundle: outcomes input length could not be read",
+          outcome: value
+        }
+      ]
+    };
+  }
+  const seenOutcomes = /* @__PURE__ */ new Set();
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    let outcome;
+    try {
+      if (!Object.hasOwn(value, i)) {
+        throw new TypeError("outcome array must be dense");
+      }
+      raw = value[i];
+      outcome = validateConsolidationOutcome(raw, i);
+    } catch (error) {
+      invalidOutcomes += 1;
+      errors.push({
+        code: "invalid-outcome",
+        message: `agenticMemoryConsolidationBundle: outcome access failed: ${errorMessage2(error)}`,
+        index: i,
+        outcome: raw,
+        validationErrors: Object.freeze(["outcome access failed"])
+      });
+      continue;
+    }
+    if (outcome.error !== void 0 || outcome.outcome === void 0) {
+      invalidOutcomes += 1;
+      if (outcome.error !== void 0) errors.push(outcome.error);
+      continue;
+    }
+    const validOutcome = outcome.outcome;
+    if (seenOutcomes.has(validOutcome.id)) {
+      invalidOutcomes += 1;
+      errors.push({
+        code: "duplicate-outcome-id",
+        message: "agenticMemoryConsolidationBundle: duplicate outcome id",
+        index: i,
+        outcomeId: validOutcome.id,
+        requestId: validOutcome.requestId,
+        outcome: raw,
+        validationErrors: Object.freeze([`duplicate outcome id '${validOutcome.id}'`])
+      });
+      continue;
+    }
+    const request = byRequest.get(validOutcome.requestId);
+    if (request === void 0) {
+      invalidOutcomes += 1;
+      errors.push({
+        code: "missing-request-ref",
+        message: "agenticMemoryConsolidationBundle: outcome references missing request",
+        index: i,
+        outcomeId: validOutcome.id,
+        requestId: validOutcome.requestId,
+        outcome: raw,
+        validationErrors: Object.freeze([`request '${validOutcome.requestId}' is not projected`])
+      });
+      continue;
+    }
+    seenOutcomes.add(validOutcome.id);
+    validOutcomes += 1;
+    if (validOutcome.kind === "failed") {
+      const resultId2 = `${validOutcome.requestId}:${validOutcome.id}`;
+      results.push(
+        Object.freeze({
+          id: resultId2,
+          requestId: validOutcome.requestId,
+          outcomeId: validOutcome.id,
+          state: "failed",
+          sourceRecordIds: request.recordIds,
+          proposedRecordIds: Object.freeze([]),
+          message: validOutcome.message,
+          ...validOutcome.provenance === void 0 ? {} : { provenance: validOutcome.provenance }
+        })
+      );
+      commands.push(
+        Object.freeze({
+          id: `${resultId2}:markFailed`,
+          kind: "markFailed",
+          requestId: validOutcome.requestId,
+          outcomeId: validOutcome.id,
+          message: validOutcome.message
+        })
+      );
+      continue;
+    }
+    const draftIds = validOutcome.records.map(
+      (record) => `${validOutcome.requestId}:${validOutcome.id}:${record.id}`
+    );
+    for (let recordIndex = 0; recordIndex < validOutcome.records.length; recordIndex += 1) {
+      proposedRecordDrafts.push(
+        Object.freeze({
+          id: draftIds[recordIndex],
+          requestId: validOutcome.requestId,
+          outcomeId: validOutcome.id,
+          record: validOutcome.records[recordIndex]
+        })
+      );
+    }
+    const resultId = `${validOutcome.requestId}:${validOutcome.id}`;
+    results.push(
+      Object.freeze({
+        id: resultId,
+        requestId: validOutcome.requestId,
+        outcomeId: validOutcome.id,
+        state: "proposed",
+        sourceRecordIds: request.recordIds,
+        proposedRecordIds: Object.freeze(validOutcome.records.map((record) => record.id)),
+        ...validOutcome.provenance === void 0 ? {} : { provenance: validOutcome.provenance }
+      })
+    );
+    commands.push(
+      Object.freeze({
+        id: `${resultId}:proposeRecords`,
+        kind: "proposeRecords",
+        requestId: validOutcome.requestId,
+        outcomeId: validOutcome.id,
+        draftIds: Object.freeze(draftIds)
+      })
+    );
+  }
+  void evaluation;
+  return {
+    results: Object.freeze(results),
+    proposedRecordDrafts: Object.freeze(proposedRecordDrafts),
+    commands: Object.freeze(commands),
+    errors,
+    validOutcomes,
+    invalidOutcomes
+  };
+}
+function validateConsolidationOutcome(value, index) {
+  if (!isPlainRecord(value)) {
+    return {
+      error: {
+        code: "invalid-outcome",
+        message: "agenticMemoryConsolidationBundle: outcome must be an object",
+        index,
+        outcome: value
+      }
+    };
+  }
+  const errors = [];
+  const id = isNonEmptyString(value.id) ? value.id : void 0;
+  const requestId = isNonEmptyString(value.requestId) ? value.requestId : void 0;
+  if (id === void 0) errors.push("outcome.id must be a non-empty string");
+  if (requestId === void 0) errors.push("outcome.requestId must be a non-empty string");
+  if (value.kind !== "proposedRecords" && value.kind !== "failed") {
+    errors.push("outcome.kind must be proposedRecords or failed");
+  }
+  if (value.provenance !== void 0 && typeof value.provenance !== "string") {
+    errors.push("outcome.provenance must be a string when present");
+  }
+  if (value.kind === "failed" && !isNonEmptyString(value.message)) {
+    errors.push("failed outcome.message must be a non-empty string");
+  }
+  const records = [];
+  if (value.kind === "proposedRecords") {
+    if (!Array.isArray(value.records)) {
+      errors.push("proposedRecords.records must be a non-empty array");
+    } else {
+      const recordsLength = safeArrayLength2(value.records);
+      const seenRecordIds = /* @__PURE__ */ new Set();
+      if (recordsLength === void 0 || recordsLength === 0) {
+        errors.push("proposedRecords.records must be a non-empty array");
+      }
+      for (let i = 0; i < (recordsLength ?? 0); i += 1) {
+        let result;
+        try {
+          if (!Object.hasOwn(value.records, i)) {
+            throw new TypeError("proposedRecords.records must be dense");
+          }
+          result = validateAndSnapshotRecord(value.records[i], i);
+        } catch (error) {
+          errors.push(`records[${i}]: record access failed: ${errorMessage2(error)}`);
+          continue;
+        }
+        if (result.record === void 0 || result.errors.length > 0) {
+          errors.push(
+            ...result.errors.flatMap((error) => error.validationErrors ?? [error.message]).map((error) => `records[${i}]: ${error}`)
+          );
+        } else if (seenRecordIds.has(result.record.id)) {
+          errors.push(`records[${i}]: duplicate proposed record id '${result.record.id}'`);
+        } else {
+          seenRecordIds.add(result.record.id);
+          records.push(result.record);
+        }
+      }
+    }
+  }
+  if (errors.length > 0 || id === void 0 || requestId === void 0) {
+    return {
+      error: {
+        code: value.kind === "proposedRecords" ? "invalid-proposed-record" : "invalid-outcome",
+        message: "agenticMemoryConsolidationBundle: outcome is invalid",
+        index,
+        outcomeId: id,
+        requestId,
+        outcome: value,
+        validationErrors: Object.freeze(errors)
+      }
+    };
+  }
+  if (value.kind === "failed") {
+    return {
+      outcome: Object.freeze({
+        id,
+        requestId,
+        kind: "failed",
+        message: value.message,
+        ...value.provenance === void 0 ? {} : { provenance: value.provenance }
+      })
+    };
+  }
+  return {
+    outcome: Object.freeze({
+      id,
+      requestId,
+      kind: "proposedRecords",
+      records: Object.freeze(records),
+      ...value.provenance === void 0 ? {} : { provenance: value.provenance }
+    })
+  };
+}
+function consolidationErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+function consolidationErrorFromRetentionError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+function packContext(contextValue, textsValue, policyValue, evaluation) {
+  const errors = [];
+  const context = validatePackingContext(contextValue, errors);
+  const texts = validateContextTexts(textsValue, errors);
+  const policy = validatePackingPolicy(policyValue, errors);
+  const packedEntries = [];
+  let omittedEntries = 0;
+  let totalChars = 0;
+  let totalCost = 0;
+  if (context !== void 0 && policy !== void 0) {
+    for (const entry of context.entries) {
+      const textFact = texts.get(entry.fragmentId);
+      if (textFact === void 0) {
+        omittedEntries += 1;
+        errors.push({
+          code: "missing-text",
+          message: "agenticMemoryContextPackingBundle: missing text projection for context entry",
+          fragmentId: entry.fragmentId,
+          validationErrors: [`missing text for fragment '${entry.fragmentId}'`]
+        });
+        continue;
+      }
+      const cost = textFact.cost ?? textFact.text.length;
+      const nextEntries = packedEntries.length + 1;
+      const separatorChars = packedEntries.length === 0 ? 0 : 2;
+      const nextChars = totalChars + separatorChars + textFact.text.length;
+      const nextCost = totalCost + cost;
+      const exceeds = policy.maxEntries !== void 0 && nextEntries > policy.maxEntries || policy.maxChars !== void 0 && nextChars > policy.maxChars || policy.maxCost !== void 0 && nextCost > policy.maxCost;
+      if (exceeds) {
+        omittedEntries += 1;
+        continue;
+      }
+      const packedEntry = Object.freeze({
+        fragmentId: entry.fragmentId,
+        text: textFact.text,
+        cost,
+        chars: textFact.text.length,
+        ...entry.record === void 0 ? {} : { record: entry.record },
+        ...policy.includeMetadata && textFact.metadata !== void 0 ? { metadata: textFact.metadata } : {}
+      });
+      packedEntries.push(packedEntry);
+      totalChars = nextChars;
+      totalCost = nextCost;
+    }
+  }
+  const cursor = Object.freeze({
+    evaluation,
+    inputEntries: context?.entries.length ?? 0,
+    packedEntries: packedEntries.length,
+    omittedEntries,
+    totalChars,
+    totalCost
+  });
+  const errorFacts = Object.freeze(
+    errors.map(
+      (error) => freezeError({
+        ...error,
+        cursor
+      })
+    )
+  );
+  const packedContext = Object.freeze({
+    entries: Object.freeze(packedEntries),
+    text: packedEntries.map((entry) => entry.text).join("\n\n"),
+    totalChars,
+    totalCost,
+    truncated: omittedEntries > 0
+  });
+  const status = Object.freeze({
+    state: agenticStatusState(errorFacts.length, packedEntries.length),
+    cursor
+  });
+  return Object.freeze({
+    packedContext,
+    status,
+    errors: errorFacts,
+    cursor
+  });
+}
+function validatePackingContext(value, errors) {
+  if (!isPlainRecord(value)) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      value
+    });
+    return void 0;
+  }
+  let entriesValue;
+  try {
+    entriesValue = value.entries;
+  } catch (error) {
+    errors.push({
+      code: "invalid-context",
+      message: `agenticMemoryContextPackingBundle: context entries access failed: ${errorMessage2(error)}`,
+      value,
+      validationErrors: ["context entries access failed"]
+    });
+    return void 0;
+  }
+  if (!Array.isArray(entriesValue)) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      value,
+      validationErrors: ["context.entries must be an array"]
+    });
+    return void 0;
+  }
+  const length = safeArrayLength2(entriesValue);
+  if (length === void 0) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context entries length could not be read",
+      value,
+      validationErrors: ["context.entries length could not be read"]
+    });
+    return void 0;
+  }
+  const entries = [];
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      raw = entriesValue[i];
+      if (!isPlainRecord(raw) || !isNonEmptyString(raw.fragmentId)) {
+        errors.push({
+          code: "invalid-context",
+          message: "agenticMemoryContextPackingBundle: context entry is invalid",
+          index: i,
+          value: raw,
+          validationErrors: ["context entry fragmentId must be a non-empty string"]
+        });
+        continue;
+      }
+      const record = validateRecordMetadata(raw.record);
+      if (!record.ok) {
+        errors.push({
+          code: "invalid-context",
+          message: "agenticMemoryContextPackingBundle: context entry record metadata is invalid",
+          index: i,
+          fragmentId: raw.fragmentId,
+          value: raw,
+          validationErrors: Object.freeze(record.errors)
+        });
+        continue;
+      }
+      entries.push(
+        Object.freeze({
+          fragmentId: raw.fragmentId,
+          ...record.metadata === void 0 ? {} : { record: record.metadata }
+        })
+      );
+    } catch (error) {
+      errors.push({
+        code: "invalid-context",
+        message: `agenticMemoryContextPackingBundle: context entry access failed: ${errorMessage2(error)}`,
+        index: i,
+        value: raw,
+        validationErrors: ["context entry access failed"]
+      });
+    }
+  }
+  return Object.freeze({
+    entries: Object.freeze(entries)
+  });
+}
+function validateContextTexts(value, errors) {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(value)) {
+    errors.push({
+      code: "invalid-texts-input",
+      message: "agenticMemoryContextPackingBundle: texts input must be an array",
+      value
+    });
+    return out;
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    errors.push({
+      code: "invalid-texts-input",
+      message: "agenticMemoryContextPackingBundle: texts input length could not be read",
+      value
+    });
+    return out;
+  }
+  for (let i = 0; i < length; i += 1) {
+    try {
+      const raw = value[i];
+      const result = validateContextText(raw, i);
+      if (result.error !== void 0) {
+        errors.push(result.error);
+        continue;
+      }
+      if (result.text === void 0) {
+        errors.push({
+          code: "invalid-text",
+          message: "agenticMemoryContextPackingBundle: text fact is invalid",
+          index: i,
+          value: raw,
+          validationErrors: ["text validation returned no fact"]
+        });
+        continue;
+      }
+      if (out.has(result.text.fragmentId)) {
+        errors.push({
+          code: "duplicate-text-fragment-id",
+          message: "agenticMemoryContextPackingBundle: duplicate text fragment id",
+          index: i,
+          fragmentId: result.text.fragmentId,
+          value: raw,
+          validationErrors: [`duplicate text fragment id '${result.text.fragmentId}'`]
+        });
+        continue;
+      }
+      out.set(result.text.fragmentId, result.text);
+    } catch (error) {
+      errors.push({
+        code: "invalid-text",
+        message: `agenticMemoryContextPackingBundle: text access failed: ${errorMessage2(error)}`,
+        index: i,
+        validationErrors: ["text access failed"]
+      });
+    }
+  }
+  return out;
+}
+function validateContextText(value, index) {
+  if (!isPlainRecord(value)) {
+    return {
+      error: {
+        code: "invalid-text",
+        message: "agenticMemoryContextPackingBundle: text fact must be an object",
+        index,
+        value
+      }
+    };
+  }
+  const errors = [];
+  if (!isNonEmptyString(value.fragmentId)) errors.push("fragmentId must be a non-empty string");
+  if (typeof value.text !== "string") errors.push("text must be a string");
+  if (value.cost !== void 0 && (typeof value.cost !== "number" || !Number.isFinite(value.cost) || value.cost < 0)) {
+    errors.push("cost must be a finite number >= 0");
+  }
+  if (value.metadata !== void 0) {
+    try {
+      if (!isPlainRecord(value.metadata)) {
+        throw new TypeError("metadata must be a plain object when present");
+      }
+      assertStrictJsonValue(value.metadata, "metadata");
+    } catch (error) {
+      errors.push(errorMessage2(error));
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      error: {
+        code: "invalid-text",
+        message: "agenticMemoryContextPackingBundle: text fact is invalid",
+        index,
+        fragmentId: typeof value.fragmentId === "string" ? value.fragmentId : void 0,
+        value,
+        validationErrors: Object.freeze(errors)
+      }
+    };
+  }
+  return {
+    text: Object.freeze({
+      fragmentId: value.fragmentId,
+      text: value.text,
+      ...value.cost === void 0 ? {} : { cost: value.cost },
+      ...value.metadata === void 0 ? {} : { metadata: Object.freeze({ ...value.metadata }) }
+    })
+  };
+}
+function validatePackingPolicy(value, errors) {
+  if (!isPlainRecord(value)) {
+    errors.push({
+      code: "invalid-policy",
+      message: "agenticMemoryContextPackingBundle: policy must be an object",
+      value
+    });
+    return void 0;
+  }
+  const validation = [];
+  let maxEntries;
+  let maxChars;
+  let maxCost;
+  let includeMetadata;
+  try {
+    maxEntries = value.maxEntries;
+    maxChars = value.maxChars;
+    maxCost = value.maxCost;
+    includeMetadata = value.includeMetadata;
+  } catch (error) {
+    errors.push({
+      code: "invalid-policy",
+      message: `agenticMemoryContextPackingBundle: policy access failed: ${errorMessage2(error)}`,
+      value,
+      validationErrors: ["policy access failed"]
+    });
+    return void 0;
+  }
+  if (maxEntries !== void 0 && (typeof maxEntries !== "number" || !Number.isSafeInteger(maxEntries) || maxEntries < 0)) {
+    validation.push("maxEntries must be a safe integer >= 0");
+  }
+  if (maxChars !== void 0 && (typeof maxChars !== "number" || !Number.isSafeInteger(maxChars) || maxChars < 0)) {
+    validation.push("maxChars must be a safe integer >= 0");
+  }
+  if (maxCost !== void 0 && (typeof maxCost !== "number" || !Number.isFinite(maxCost) || maxCost < 0)) {
+    validation.push("maxCost must be a finite number >= 0");
+  }
+  if (includeMetadata !== void 0 && typeof includeMetadata !== "boolean") {
+    validation.push("includeMetadata must be a boolean when present");
+  }
+  if (validation.length > 0) {
+    errors.push({
+      code: "invalid-policy",
+      message: "agenticMemoryContextPackingBundle: policy is invalid",
+      value,
+      validationErrors: Object.freeze(validation)
+    });
+    return void 0;
+  }
+  return Object.freeze({
+    ...maxEntries === void 0 ? {} : { maxEntries },
+    ...maxChars === void 0 ? {} : { maxChars },
+    ...maxCost === void 0 ? {} : { maxCost },
+    ...includeMetadata === void 0 ? {} : { includeMetadata }
+  });
+}
+function validateAndProjectRecords(value) {
+  const records = [];
+  const fragments = [];
+  const metadataByFragmentId = /* @__PURE__ */ Object.create(null);
+  const errors = [];
+  const invalidRecordIndexes = /* @__PURE__ */ new Set();
+  const seenRecordIds = /* @__PURE__ */ new Set();
+  const seenFragmentIds = /* @__PURE__ */ new Set();
+  if (!Array.isArray(value)) {
+    errors.push({
+      code: "invalid-records-input",
+      message: "agenticMemoryBundle: records input must be an array",
+      record: value
+    });
+    return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+  }
+  const length = safeArrayLength2(value);
+  if (length === void 0) {
+    errors.push({
+      code: "invalid-records-input",
+      message: "agenticMemoryBundle: records input length could not be read",
+      record: value
+    });
+    return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+  }
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      raw = value[i];
+    } catch (error) {
+      invalidRecordIndexes.add(i);
+      errors.push({
+        code: "invalid-record",
+        message: `agenticMemoryBundle: record access failed: ${errorMessage2(error)}`,
+        index: i,
+        validationErrors: Object.freeze(["record access failed"])
+      });
+      continue;
+    }
+    const result = validateAndSnapshotRecord(raw, i);
+    if (result.errors.length > 0) {
+      invalidRecordIndexes.add(i);
+      errors.push(...result.errors);
+      continue;
+    }
+    if (result.record === void 0) continue;
+    if (seenRecordIds.has(result.record.id)) {
+      invalidRecordIndexes.add(i);
+      errors.push({
+        code: "duplicate-record-id",
+        message: "agenticMemoryBundle: duplicate record id",
+        index: i,
+        recordId: result.record.id,
+        record: raw,
+        validationErrors: [`duplicate record id '${result.record.id}'`]
+      });
+      continue;
+    }
+    if (seenFragmentIds.has(result.record.fragment.id)) {
+      invalidRecordIndexes.add(i);
+      errors.push({
+        code: "duplicate-fragment-id",
+        message: "agenticMemoryBundle: duplicate fragment id",
+        index: i,
+        recordId: result.record.id,
+        fragmentId: result.record.fragment.id,
+        record: raw,
+        validationErrors: [`duplicate fragment id '${result.record.fragment.id}'`]
+      });
+      continue;
+    }
+    seenRecordIds.add(result.record.id);
+    seenFragmentIds.add(result.record.fragment.id);
+    records.push(result.record);
+    fragments.push(result.record.fragment);
+    metadataByFragmentId[result.record.fragment.id] = recordMetadata(result.record);
+  }
+  return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+}
+function validateAndSnapshotRecord(value, index) {
+  try {
+    return validateAndSnapshotRecordInner(value, index);
+  } catch (error) {
+    return {
+      errors: [
+        {
+          code: "invalid-record",
+          message: `agenticMemoryBundle: record access failed: ${errorMessage2(error)}`,
+          index,
+          record: value,
+          validationErrors: Object.freeze(["record access failed"])
+        }
+      ]
+    };
+  }
+}
+function validateAndSnapshotRecordInner(value, index) {
+  const errors = [];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {
+      errors: [
+        {
+          code: "invalid-record",
+          message: "agenticMemoryBundle: record must be an object",
+          index,
+          record: value
+        }
+      ]
+    };
+  }
+  const record = value;
+  const recordId = typeof record.id === "string" ? record.id : void 0;
+  if (recordId === void 0 || recordId.length === 0) {
+    errors.push({
+      code: "invalid-record",
+      message: "agenticMemoryBundle: record.id must be a non-empty string",
+      index,
+      record: value,
+      validationErrors: ["record.id must be a non-empty string"]
+    });
+  }
+  if (!isAgenticMemoryKind(record.kind)) {
+    errors.push({
+      code: "invalid-record-kind",
+      message: "agenticMemoryBundle: record.kind is invalid",
+      index,
+      recordId,
+      record: value,
+      validationErrors: ["kind must be one of working, episodic, semantic, procedural, profile"]
+    });
+  }
+  if (!isAgenticMemoryPersistenceLevel(record.persistenceLevel)) {
+    errors.push({
+      code: "invalid-persistence-level",
+      message: "agenticMemoryBundle: record.persistenceLevel is invalid",
+      index,
+      recordId,
+      record: value,
+      validationErrors: [
+        "persistenceLevel must be one of turn, session, project, longTerm, permanent, archived"
+      ]
+    });
+  }
+  if (!isAgenticMemoryArtifactKind(record.artifactKind)) {
+    errors.push({
+      code: "invalid-artifact-kind",
+      message: "agenticMemoryBundle: record.artifactKind is invalid",
+      index,
+      recordId,
+      record: value,
+      validationErrors: ["artifactKind must be one of raw, insight, profile, procedure"]
+    });
+  }
+  const scopeValidation = validateScope(record.scope);
+  if (!scopeValidation.ok) {
+    errors.push({
+      code: "invalid-scope",
+      message: "agenticMemoryBundle: record.scope is invalid",
+      index,
+      recordId,
+      record: value,
+      validationErrors: Object.freeze(scopeValidation.errors)
+    });
+  }
+  const fragmentValidation = validateMemoryFragment(record.fragment);
+  if (!fragmentValidation.ok) {
+    errors.push({
+      code: "invalid-fragment",
+      message: "agenticMemoryBundle: record.fragment is invalid",
+      index,
+      recordId,
+      fragmentId: typeof record.fragment === "object" && record.fragment !== null && typeof record.fragment.id === "string" ? record.fragment.id : void 0,
+      record: value,
+      validationErrors: Object.freeze([...fragmentValidation.errors])
+    });
+  }
+  const forbiddenFields = [
+    "storageTier",
+    "storageKey",
+    "adapter",
+    "collection",
+    "collections",
+    "ttl",
+    "ttlMs",
+    "ttlNs",
+    "expiresAt",
+    "timer",
+    "scheduler",
+    "schedule",
+    "retentionTimer",
+    "consolidationSchedule",
+    "reflectionSchedule",
+    "llm",
+    "llmHandle",
+    "tool",
+    "toolHandle",
+    "runner",
+    "runnerHandle",
+    "restore",
+    "hydrate",
+    "hydration",
+    "graphMutation",
+    "protocol"
+  ];
+  const presentForbidden = forbiddenFields.filter((field) => Object.hasOwn(record, field));
+  if (presentForbidden.length > 0) {
+    errors.push({
+      code: "invalid-record",
+      message: "agenticMemoryBundle: record contains forbidden runtime/persistence fields",
+      index,
+      recordId,
+      record: value,
+      validationErrors: Object.freeze(
+        presentForbidden.map((field) => `${field} is not part of AgenticMemoryRecord`)
+      )
+    });
+  }
+  if (errors.length > 0) return { errors };
+  const scope = scopeValidation.scope;
+  const fragment = snapshotFragment2(record.fragment);
+  return {
+    record: Object.freeze({
+      id: recordId,
+      kind: record.kind,
+      persistenceLevel: record.persistenceLevel,
+      artifactKind: record.artifactKind,
+      ...scope === void 0 ? {} : { scope },
+      fragment
+    }),
+    errors
+  };
+}
+function snapshotFragment2(fragment) {
+  return Object.freeze({
+    id: fragment.id,
+    payload: fragment.payload,
+    tNs: fragment.tNs,
+    ...fragment.validFrom === void 0 ? {} : { validFrom: fragment.validFrom },
+    ...fragment.validTo === void 0 ? {} : { validTo: fragment.validTo },
+    confidence: fragment.confidence,
+    tags: Object.freeze([...fragment.tags]),
+    sources: Object.freeze([...fragment.sources]),
+    ...fragment.embedding === void 0 ? {} : { embedding: Object.freeze([...fragment.embedding]) },
+    ...fragment.parentFragmentId === void 0 ? {} : { parentFragmentId: fragment.parentFragmentId },
+    ...fragment.provenance === void 0 ? {} : { provenance: fragment.provenance }
+  });
+}
+function recordMetadata(record) {
+  return Object.freeze({
+    recordId: record.id,
+    kind: record.kind,
+    persistenceLevel: record.persistenceLevel,
+    artifactKind: record.artifactKind,
+    ...record.scope === void 0 ? {} : { scope: record.scope }
+  });
+}
+function validateRecordMetadata(value) {
+  if (value === void 0) return { ok: true, errors: [] };
+  if (!isPlainRecord(value)) {
+    return { ok: false, errors: ["record metadata must be an object when present"] };
+  }
+  const errors = [];
+  for (const key of Object.keys(value)) {
+    if (key !== "recordId" && key !== "kind" && key !== "persistenceLevel" && key !== "artifactKind" && key !== "scope") {
+      errors.push(`record.${key} is not part of AgenticMemoryRecordMetadata`);
+    }
+  }
+  if (!isNonEmptyString(value.recordId)) {
+    errors.push("record.recordId must be a non-empty string");
+  }
+  if (!isAgenticMemoryKind(value.kind)) {
+    errors.push("record.kind is invalid");
+  }
+  if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+    errors.push("record.persistenceLevel is invalid");
+  }
+  if (!isAgenticMemoryArtifactKind(value.artifactKind)) {
+    errors.push("record.artifactKind is invalid");
+  }
+  const scopeValidation = validateScope(value.scope);
+  if (!scopeValidation.ok) {
+    errors.push(...scopeValidation.errors.map((error) => `record.${error}`));
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return {
+    ok: true,
+    errors,
+    metadata: Object.freeze({
+      recordId: value.recordId,
+      kind: value.kind,
+      persistenceLevel: value.persistenceLevel,
+      artifactKind: value.artifactKind,
+      ...scopeValidation.scope === void 0 ? {} : { scope: scopeValidation.scope }
+    })
+  };
+}
+function contextState(projection, retrieval) {
+  if (projection === "error" || retrieval === "error") return "error";
+  if (projection === "partial" || retrieval === "partial") return "partial";
+  return retrieval;
+}
+function agenticStatusState(errorCount, validRecords) {
+  if (errorCount > 0 && validRecords === 0) return "error";
+  if (errorCount > 0) return "partial";
+  return validRecords > 0 ? "ready" : "empty";
+}
+function isAgenticMemoryKind(value) {
+  return value === "working" || value === "episodic" || value === "semantic" || value === "procedural" || value === "profile";
+}
+function isAgenticMemoryPersistenceLevel(value) {
+  return value === "turn" || value === "session" || value === "project" || value === "longTerm" || value === "permanent" || value === "archived";
+}
+function isAgenticMemoryArtifactKind(value) {
+  return value === "raw" || value === "insight" || value === "profile" || value === "procedure";
+}
+function validateScope(value) {
+  if (value === void 0) return { ok: true, errors: [] };
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, errors: ["scope must be an object when present"] };
+  }
+  const scope = value;
+  const errors = [];
+  const allowed = /* @__PURE__ */ new Set(["sessionId", "projectId", "userId", "tenantId"]);
+  for (const key of Object.keys(scope)) {
+    if (!allowed.has(key)) errors.push(`scope.${key} is not part of AgenticMemoryScope`);
+  }
+  for (const key of allowed) {
+    if (scope[key] !== void 0 && (typeof scope[key] !== "string" || scope[key].length === 0)) {
+      errors.push(`scope.${key} must be a non-empty string when present`);
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return {
+    ok: true,
+    errors,
+    scope: Object.freeze({
+      ...scope.sessionId === void 0 ? {} : { sessionId: scope.sessionId },
+      ...scope.projectId === void 0 ? {} : { projectId: scope.projectId },
+      ...scope.userId === void 0 ? {} : { userId: scope.userId },
+      ...scope.tenantId === void 0 ? {} : { tenantId: scope.tenantId }
+    })
+  };
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function ownKeys(value) {
+  return Object.keys(value).sort();
+}
+function assertExactKeys(value, expected, label) {
+  const actual = ownKeys(value);
+  const want = [...expected].sort();
+  if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+    throw new TypeError(`${label}: unexpected fields ${actual.join(",")}`);
+  }
+}
+function assertAgenticMemoryRecordCodecShape(value) {
+  if (!isPlainRecord(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+  }
+  assertNoSymbolKeys(value, "agenticMemoryRecordFrame.record");
+  assertExactKeys(
+    value,
+    value.scope === void 0 ? ["artifactKind", "fragment", "id", "kind", "persistenceLevel"] : ["artifactKind", "fragment", "id", "kind", "persistenceLevel", "scope"],
+    "agenticMemoryRecordFrame.record"
+  );
+  const fragment = value.fragment;
+  if (!isPlainRecord(fragment)) {
+    throw new TypeError("agenticMemoryRecordFrame: fragment must be an object");
+  }
+  assertNoSymbolKeys(fragment, "agenticMemoryRecordFrame.record.fragment");
+  assertExactKeys(
+    fragment,
+    [
+      "id",
+      "payload",
+      "tNs",
+      ...fragment.validFrom === void 0 ? [] : ["validFrom"],
+      ...fragment.validTo === void 0 ? [] : ["validTo"],
+      "confidence",
+      "tags",
+      "sources",
+      ...fragment.embedding === void 0 ? [] : ["embedding"],
+      ...fragment.parentFragmentId === void 0 ? [] : ["parentFragmentId"],
+      ...fragment.provenance === void 0 ? [] : ["provenance"]
+    ],
+    "agenticMemoryRecordFrame.record.fragment"
+  );
+  assertStrictJsonValue(fragment.tags, "record.fragment.tags");
+  assertStrictJsonValue(fragment.sources, "record.fragment.sources");
+  if (fragment.embedding !== void 0) {
+    assertStrictJsonValue(fragment.embedding, "record.fragment.embedding");
+  }
+  if (value.scope !== void 0) assertScopeFrame(value.scope);
+}
+function assertNoSymbolKeys(value, label) {
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError(`${label}: unexpected symbol fields`);
+  }
+}
+function decimalBigIntString(value, label) {
+  const out = value.toString(10);
+  if (!/^-?(0|[1-9]\d*)$/.test(out)) {
+    throw new TypeError(`${label} must encode as a canonical decimal bigint string`);
+  }
+  return out;
+}
+function parseDecimalBigInt(value, label) {
+  if (typeof value !== "string" || !/^(0|-?[1-9]\d*)$/.test(value)) {
+    throw new TypeError(`${label} must be a canonical decimal bigint string`);
+  }
+  return BigInt(value);
+}
+function assertStrictJsonValue(value, label) {
+  try {
+    strictJsonCodec.encode(value);
+    return value;
+  } catch (error) {
+    throw new TypeError(`${label} must be strict JSON: ${errorMessage2(error)}`);
+  }
+}
+function assertScopeFrame(value) {
+  if (!isPlainRecord(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: scope must be an object when present");
+  }
+  assertStrictJsonValue(value, "record.scope");
+  const validation = validateScope(value);
+  if (!validation.ok || validation.scope === void 0) {
+    throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
+  }
+  assertExactKeys(
+    value,
+    [
+      ...value.sessionId === void 0 ? [] : ["sessionId"],
+      ...value.projectId === void 0 ? [] : ["projectId"],
+      ...value.userId === void 0 ? [] : ["userId"],
+      ...value.tenantId === void 0 ? [] : ["tenantId"]
+    ],
+    "agenticMemoryRecordFrame.record.scope"
+  );
+  return validation.scope;
+}
+function assertKindValue(value) {
+  if (!isAgenticMemoryKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid memory kind");
+  }
+  return value;
+}
+function assertPersistenceLevelValue(value) {
+  if (!isAgenticMemoryPersistenceLevel(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
+  }
+  return value;
+}
+function assertArtifactKindValue(value) {
+  if (!isAgenticMemoryArtifactKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
+  }
+  return value;
+}
+function assertNonEmptyString(value, label) {
+  if (!isNonEmptyString(value)) throw new TypeError(`${label} must be a non-empty string`);
+  return value;
+}
+function assertString(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+  return value;
+}
+function assertConfidence(value, label) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new TypeError(`${label} must be a finite number in [0, 1]`);
+  }
+  return value;
+}
+function assertStringArray(value, label) {
+  if (!isDenseArrayOf3(value, (item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a readonly string array`);
+  }
+  return Object.freeze([...value]);
+}
+function assertFiniteNumberArray(value, label) {
+  if (!isDenseArrayOf3(value, (item) => Number.isFinite(item))) {
+    throw new TypeError(`${label} must be a finite number array`);
+  }
+  return Object.freeze([...value]);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isDenseArrayOf3(value, predicate) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+  }
+  return true;
+}
+function freezeError(error) {
+  return Object.freeze({
+    ...error,
+    ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) }
+  });
+}
+function safeArrayLength2(value) {
+  try {
+    return value.length;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+  AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+  agenticMemoryBundle,
+  agenticMemoryConsolidationBundle,
+  agenticMemoryContextPackingBundle,
+  agenticMemoryKgProjectionBundle,
+  agenticMemoryRecordCodec,
+  agenticMemoryRecordFrame,
+  agenticMemoryRecordFrameCodec,
+  agenticMemoryRetentionBundle,
+  assertAgenticMemoryRecordFrame
+});
+//# sourceMappingURL=index.cjs.map