@graphrefly/ts 0.0.1 → 0.0.2

package/dist/{chunk-YDSIVHRR.js → chunk-4NWSNI4K.js}

@@ -1,1210 +1,838 @@
 import {
   memoryRetrievalBundle,
   validateMemoryFragment
-} from "./chunk-FBUU43PM.js";
+} from "./chunk-E4QCH32M.js";
 import {
   depBatch,
   depLatest
 } from "./chunk-WQIA3GFB.js";
 import {
   strictJsonCodec
-} from "./chunk-4VLAQHZI.js";
+} from "./chunk-K7FB3JTD.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
+// src/solutions/agentic-memory-shared.ts
+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"])
       });
-      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
+      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}'`]
       });
-      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
+      continue;
     }
-  );
-  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("; ")}`
-    );
+    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);
   }
-  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)
-    })
-  });
+  return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
 }
-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");
+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"])
+        }
+      ]
+    };
   }
-  if (value.version !== AGENTIC_MEMORY_RECORD_FRAME_VERSION) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid version");
+}
+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 rawRecord = value.record;
-  if (!isPlainRecord(rawRecord)) {
-    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+  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"]
+    });
   }
-  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");
+  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"]
+    });
   }
-  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
-    }
-  );
+  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 {
-    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
-    )
+    record: Object.freeze({
+      id: recordId,
+      kind: record.kind,
+      persistenceLevel: record.persistenceLevel,
+      artifactKind: record.artifactKind,
+      ...scope === void 0 ? {} : { scope },
+      fragment
+    }),
+    errors
   };
 }
-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 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 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);
+function recordMetadata(record) {
   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")
+    recordId: record.id,
+    kind: record.kind,
+    persistenceLevel: record.persistenceLevel,
+    artifactKind: record.artifactKind,
+    ...record.scope === void 0 ? {} : { scope: record.scope }
   });
 }
-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 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 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
-        }
-      ]
-    };
+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 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 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`);
   }
-  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"]
-      });
+  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`);
     }
   }
-  return { assertions, errors, invalidDrafts };
+  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 validateKgDraft(value, index) {
-  const errors = [];
+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)) {
-    return {
-      errors: [
-        {
-          code: "invalid-draft",
-          message: "agenticMemoryKgProjectionBundle: draft must be an object",
-          index,
-          draft: value
-        }
-      ]
-    };
+    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
   }
-  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");
+  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 (fragmentId === void 0) {
-    shapeErrors.push("draft.fragmentId must be a non-empty string");
+  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`);
   }
-  shapeErrors.push(...subject.errors);
-  if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
-    shapeErrors.push("draft.predicate must be a non-empty string");
+}
+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`);
   }
-  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]");
+  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`);
   }
-  if (raw.sources !== void 0 && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
-    shapeErrors.push("draft.sources must be a readonly string array");
+  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)}`);
   }
-  if (raw.provenance !== void 0 && typeof raw.provenance !== "string") {
-    shapeErrors.push("draft.provenance must be a string when present");
+}
+function assertScopeFrame(value) {
+  if (!isPlainRecord(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: scope must be an object 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 };
+  assertStrictJsonValue(value, "record.scope");
+  const validation = validateScope(value);
+  if (!validation.ok || validation.scope === void 0) {
+    throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
   }
-  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
-  };
+  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 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");
+function assertKindValue(value) {
+  if (!isAgenticMemoryKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid memory kind");
   }
-  if (errors.length > 0) return { errors };
-  return {
-    subject: Object.freeze({
-      id,
-      ...type === void 0 ? {} : { type }
-    }),
-    errors
-  };
+  return value;
 }
-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
-    };
+function assertPersistenceLevelValue(value) {
+  if (!isAgenticMemoryPersistenceLevel(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
   }
-  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 value;
+}
+function assertArtifactKindValue(value) {
+  if (!isAgenticMemoryArtifactKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
   }
-  return { errors: ["object.kind must be entity or value"] };
+  return 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 assertNonEmptyString(value, label) {
+  if (!isNonEmptyString(value)) throw new TypeError(`${label} must be a non-empty string`);
+  return value;
 }
-function kgErrorFromRecordError(error) {
-  return {
-    ...error,
-    code: error.code
-  };
+function assertString(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+  return value;
 }
-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 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 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("; ")}`
-    );
+function assertStringArray(value, label) {
+  if (!isDenseArrayOf(value, (item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a readonly string array`);
   }
-  return result.record;
+  return Object.freeze([...value]);
 }
-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
-        }
-      ]
-    };
+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;
   }
-  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
-        }
-      ]
-    };
+  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;
   }
-  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;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/solutions/agentic-memory-projection.ts
+function solutionProjection(graph, snapshot, name, factory, select) {
+  return graph.node(
+    [snapshot],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", select(raw)]]);
       }
-      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;
+    },
+    {
+      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)]]);
       }
-      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;
+    },
+    {
+      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)]
+        ]);
       }
-      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"]
+    },
+    {
+      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
     }
-  }
-  const projected = records.map((record) => view.get(record.id) ?? record);
+  );
+}
+
+// src/solutions/agentic-memory-bundle.ts
+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 {
-    activeRecords: projected.filter((record) => record.persistenceLevel !== "archived"),
-    archivedRecords: projected.filter((record) => record.persistenceLevel === "archived"),
-    consolidationRequests: requests,
+    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,
-    validCommands,
-    invalidCommands
+    retrievalStatus: retrieval.status,
+    retrievalErrors: retrieval.errors,
+    cursor: retrieval.cursor
   };
 }
-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");
+
+// src/solutions/agentic-memory-consolidation.ts
+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
     }
-  }
-  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
+    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 validateConsolidationRequests(value, records) {
@@ -1590,6 +1218,64 @@ function consolidationErrorFromRetentionError(error) {
     code: error.code
   };
 }
+
+// src/solutions/agentic-memory-context-packing.ts
+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 packContext(contextValue, textsValue, policyValue, evaluation) {
   const errors = [];
   const context = validatePackingContext(contextValue, errors);
@@ -1920,517 +1606,845 @@ function validatePackingPolicy(value, errors) {
     ...includeMetadata === void 0 ? {} : { includeMetadata }
   });
 }
-function validateAndProjectRecords(value) {
-  const records = [];
-  const fragments = [];
-  const metadataByFragmentId = /* @__PURE__ */ Object.create(null);
+
+// src/solutions/agentic-memory-frame.ts
+var AGENTIC_MEMORY_RECORD_FRAME_FORMAT = "graphrefly.agenticMemoryRecord";
+var AGENTIC_MEMORY_RECORD_FRAME_VERSION = 1;
+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 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;
+}
+
+// src/solutions/agentic-memory-kg.ts
+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 validateAndProjectKgDrafts(value, records) {
+  const assertions = [];
   const errors = [];
-  const invalidRecordIndexes = /* @__PURE__ */ new Set();
-  const seenRecordIds = /* @__PURE__ */ new Set();
-  const seenFragmentIds = /* @__PURE__ */ new Set();
+  let invalidDrafts = 0;
   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 };
+    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) {
-    errors.push({
-      code: "invalid-records-input",
-      message: "agenticMemoryBundle: records input length could not be read",
-      record: value
-    });
-    return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+    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) {
-      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);
+      invalidDrafts += 1;
       errors.push({
-        code: "duplicate-fragment-id",
-        message: "agenticMemoryBundle: duplicate fragment id",
+        code: "invalid-draft",
+        message: `agenticMemoryKgProjectionBundle: draft access failed: ${errorMessage(error)}`,
         index: i,
-        recordId: result.record.id,
-        fragmentId: result.record.fragment.id,
-        record: raw,
-        validationErrors: [`duplicate fragment id '${result.record.fragment.id}'`]
+        draft: raw,
+        validationErrors: ["draft access failed"]
       });
-      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"])
-        }
-      ]
-    };
   }
+  return { assertions, errors, invalidDrafts };
 }
-function validateAndSnapshotRecordInner(value, index) {
+function validateKgDraft(value, index) {
   const errors = [];
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+  if (!isPlainRecord(value)) {
     return {
       errors: [
         {
-          code: "invalid-record",
-          message: "agenticMemoryBundle: record must be an object",
+          code: "invalid-draft",
+          message: "agenticMemoryKgProjectionBundle: draft must be an object",
           index,
-          record: value
+          draft: 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"]
-    });
+  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 (!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 (fragmentId === void 0) {
+    shapeErrors.push("draft.fragmentId must be a non-empty string");
   }
-  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"
-      ]
-    });
+  shapeErrors.push(...subject.errors);
+  if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
+    shapeErrors.push("draft.predicate must be a non-empty string");
   }
-  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"]
-    });
+  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]");
   }
-  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)
-    });
+  if (raw.sources !== void 0 && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
+    shapeErrors.push("draft.sources must be a readonly string array");
   }
-  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])
-    });
+  if (raw.provenance !== void 0 && typeof raw.provenance !== "string") {
+    shapeErrors.push("draft.provenance must be a string when present");
   }
-  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 (shapeErrors.length > 0) errors.push(kgShapeError(index, value, ...shapeErrors));
+  if (errors.length > 0 || id === void 0 || recordId === void 0 || fragmentId === void 0) {
+    return { errors };
   }
-  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
+    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 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"] };
-  }
+function validateAssertionSubject(value) {
+  if (!isPlainRecord(value)) return { errors: ["subject must be an object"] };
+  const id = value.id;
+  const type = value.type;
   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 (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 { ok: false, errors };
+  if (errors.length > 0) return { 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 }
-    })
+    subject: Object.freeze({
+      id,
+      ...type === void 0 ? {} : { type }
+    }),
+    errors
   };
 }
-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;
+function validateAssertionObject(value) {
+  if (!isPlainRecord(value)) return { errors: ["object must be an object"] };
+  const kind = value.kind;
   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`);
+  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
+    };
   }
-  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 (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
+    };
   }
-  if (errors.length > 0) return { ok: false, errors };
+  return { errors: ["object.kind must be entity or value"] };
+}
+function kgShapeError(index, draft, ...validationErrors) {
   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 }
-    })
+    code: "invalid-assertion-shape",
+    message: "agenticMemoryKgProjectionBundle: draft assertion shape is invalid",
+    index,
+    draft,
+    validationErrors: Object.freeze([...validationErrors])
   };
 }
-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 kgErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
 }
-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"
+
+// src/solutions/agentic-memory-retention.ts
+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
+    }
   );
-  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`);
-  }
+  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 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`);
+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
+        }
+      ]
+    };
   }
-  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`);
+  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
+        }
+      ]
+    };
   }
-  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)}`);
+  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 assertScopeFrame(value) {
+function validateRetentionCommand(value, index) {
   if (!isPlainRecord(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: scope must be an object when present");
+    return {
+      errors: [
+        {
+          code: "invalid-command",
+          message: "agenticMemoryRetentionBundle: command must be an object",
+          index,
+          command: value
+        }
+      ]
+    };
   }
-  assertStrictJsonValue(value, "record.scope");
-  const validation = validateScope(value);
-  if (!validation.ok || validation.scope === void 0) {
-    throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
+  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");
   }
-  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");
+  if (value.reason !== void 0 && typeof value.reason !== "string") {
+    errors.push("command.reason must be a string when present");
   }
-  return value;
-}
-function assertPersistenceLevelValue(value) {
-  if (!isAgenticMemoryPersistenceLevel(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
+  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");
+    }
   }
-  return value;
-}
-function assertArtifactKindValue(value) {
-  if (!isAgenticMemoryArtifactKind(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
+  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)
+        }
+      ]
+    };
   }
-  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]`);
+  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: []
+    };
   }
-  return value;
-}
-function assertStringArray(value, label) {
-  if (!isDenseArrayOf(value, (item) => typeof item === "string")) {
-    throw new TypeError(`${label} must be a readonly string array`);
+  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: []
+    };
   }
-  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`);
+  if (kind === "setPersistenceLevel") {
+    return {
+      command: Object.freeze({
+        ...base,
+        kind,
+        recordId: value.recordId,
+        persistenceLevel: value.persistenceLevel,
+        ...base.reason === void 0 ? {} : { reason: base.reason }
+      }),
+      errors: []
+    };
   }
-  return Object.freeze([...value]);
+  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 isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
+function retentionMissingRecords(command, records) {
+  if ("recordId" in command) return records.has(command.recordId) ? [] : [command.recordId];
+  return command.recordIds.filter((recordId) => !records.has(recordId));
 }
-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;
+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;
   }
-  return true;
+  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 freezeError(error) {
+function nonArchivedLevel(record) {
+  return record.persistenceLevel === "archived" ? "session" : record.persistenceLevel;
+}
+function withPersistenceLevel(record, persistenceLevel) {
   return Object.freeze({
-    ...error,
-    ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) }
+    ...record,
+    persistenceLevel
   });
 }
-function safeArrayLength(value) {
-  try {
-    return value.length;
-  } catch {
-    return void 0;
-  }
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function retentionErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
 }
 
 // src/solutions/capability-admission.ts
@@ -2978,18 +2992,18 @@ function ref(kind, id) {
 }
 
 export {
+  agenticMemoryBundle,
+  agenticMemoryConsolidationBundle,
+  agenticMemoryContextPackingBundle,
   AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
   AGENTIC_MEMORY_RECORD_FRAME_VERSION,
-  agenticMemoryBundle,
-  agenticMemoryKgProjectionBundle,
   agenticMemoryRecordFrame,
   assertAgenticMemoryRecordFrame,
   agenticMemoryRecordFrameCodec,
   agenticMemoryRecordCodec,
+  agenticMemoryKgProjectionBundle,
   agenticMemoryRetentionBundle,
-  agenticMemoryConsolidationBundle,
-  agenticMemoryContextPackingBundle,
   capabilityAdmissionProposal,
   capabilityAdmissionProjector
 };
-//# sourceMappingURL=chunk-YDSIVHRR.js.map
+//# sourceMappingURL=chunk-4NWSNI4K.js.map