@graphrefly/ts 0.0.0

package/dist/chunk-COHO25CZ.js

@@ -0,0 +1,2449 @@
+import {
+  memoryRetrievalBundle,
+  validateMemoryFragment
+} from "./chunk-JIMUDQN3.js";
+import {
+  strictJsonCodec
+} from "./chunk-4VLAQHZI.js";
+import {
+  depBatch,
+  depLatest
+} from "./chunk-SWTLEQL6.js";
+
+// 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 = safeArrayLength(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: ${errorMessage(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 && !isDenseArrayOf(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(errorMessage(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 = safeArrayLength(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: ${errorMessage(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 (!isDenseArrayOf(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 = safeArrayLength(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: ${errorMessage(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 = isDenseArrayOf(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 = safeArrayLength(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: ${errorMessage(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 = safeArrayLength(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: ${errorMessage(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: ${errorMessage(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 = safeArrayLength(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: ${errorMessage(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 = safeArrayLength(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: ${errorMessage(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(errorMessage(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: ${errorMessage(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 = safeArrayLength(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: ${errorMessage(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: ${errorMessage(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 = snapshotFragment(record.fragment);
+  return {
+    record: Object.freeze({
+      id: recordId,
+      kind: record.kind,
+      persistenceLevel: record.persistenceLevel,
+      artifactKind: record.artifactKind,
+      ...scope === void 0 ? {} : { scope },
+      fragment
+    }),
+    errors
+  };
+}
+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 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: ${errorMessage(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 (!isDenseArrayOf(value, (item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a readonly string array`);
+  }
+  return Object.freeze([...value]);
+}
+function assertFiniteNumberArray(value, label) {
+  if (!isDenseArrayOf(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 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;
+}
+function freezeError(error) {
+  return Object.freeze({
+    ...error,
+    ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) }
+  });
+}
+function safeArrayLength(value) {
+  try {
+    return value.length;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+  AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+  agenticMemoryBundle,
+  agenticMemoryKgProjectionBundle,
+  agenticMemoryRecordFrame,
+  assertAgenticMemoryRecordFrame,
+  agenticMemoryRecordFrameCodec,
+  agenticMemoryRecordCodec,
+  agenticMemoryRetentionBundle,
+  agenticMemoryConsolidationBundle,
+  agenticMemoryContextPackingBundle
+};
+//# sourceMappingURL=chunk-COHO25CZ.js.map