@graphrefly/ts 0.0.0 → 0.0.2

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

@@ -1,520 +1,530 @@
 import {
   memoryRetrievalBundle,
   validateMemoryFragment
-} from "./chunk-JIMUDQN3.js";
-import {
-  strictJsonCodec
-} from "./chunk-4VLAQHZI.js";
+} from "./chunk-E4QCH32M.js";
 import {
   depBatch,
   depLatest
-} from "./chunk-SWTLEQL6.js";
+} from "./chunk-WQIA3GFB.js";
+import {
+  strictJsonCodec
+} 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() {
+  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 {
-    encode(value) {
-      return strictJsonCodec.encode(assertAgenticMemoryRecordFrame(value));
-    },
-    decode(bytes) {
-      return assertAgenticMemoryRecordFrame(strictJsonCodec.decode(bytes));
-    }
+    record: Object.freeze({
+      id: recordId,
+      kind: record.kind,
+      persistenceLevel: record.persistenceLevel,
+      artifactKind: record.artifactKind,
+      ...scope === void 0 ? {} : { scope },
+      fragment
+    }),
+    errors
   };
 }
-function agenticMemoryRecordCodec() {
-  const frameCodec = agenticMemoryRecordFrameCodec();
-  return {
-    encode(value) {
-      return frameCodec.encode(agenticMemoryRecordFrame(value));
-    },
-    decode(bytes) {
-      return recordFromFrame(frameCodec.decode(bytes));
-    }
-  };
+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 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
+function recordMetadata(record) {
+  return Object.freeze({
+    recordId: record.id,
+    kind: record.kind,
+    persistenceLevel: record.persistenceLevel,
+    artifactKind: record.artifactKind,
+    ...record.scope === void 0 ? {} : { scope: record.scope }
+  });
+}
+function validateRecordMetadata(value) {
+  if (value === void 0) return { ok: true, errors: [] };
+  if (!isPlainRecord(value)) {
+    return { ok: false, errors: ["record metadata must be an object when present"] };
+  }
+  const errors = [];
+  for (const key of Object.keys(value)) {
+    if (key !== "recordId" && key !== "kind" && key !== "persistenceLevel" && key !== "artifactKind" && key !== "scope") {
+      errors.push(`record.${key} is not part of AgenticMemoryRecordMetadata`);
     }
-  );
+  }
+  if (!isNonEmptyString(value.recordId)) {
+    errors.push("record.recordId must be a non-empty string");
+  }
+  if (!isAgenticMemoryKind(value.kind)) {
+    errors.push("record.kind is invalid");
+  }
+  if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+    errors.push("record.persistenceLevel is invalid");
+  }
+  if (!isAgenticMemoryArtifactKind(value.artifactKind)) {
+    errors.push("record.artifactKind is invalid");
+  }
+  const scopeValidation = validateScope(value.scope);
+  if (!scopeValidation.ok) {
+    errors.push(...scopeValidation.errors.map((error) => `record.${error}`));
+  }
+  if (errors.length > 0) return { ok: false, errors };
   return {
-    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
-    )
+    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 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
+function contextState(projection, retrieval) {
+  if (projection === "error" || retrieval === "error") return "error";
+  if (projection === "partial" || retrieval === "partial") return "partial";
+  return retrieval;
+}
+function agenticStatusState(errorCount, validRecords) {
+  if (errorCount > 0 && validRecords === 0) return "error";
+  if (errorCount > 0) return "partial";
+  return validRecords > 0 ? "ready" : "empty";
+}
+function isAgenticMemoryKind(value) {
+  return value === "working" || value === "episodic" || value === "semantic" || value === "procedural" || value === "profile";
+}
+function isAgenticMemoryPersistenceLevel(value) {
+  return value === "turn" || value === "session" || value === "project" || value === "longTerm" || value === "permanent" || value === "archived";
+}
+function isAgenticMemoryArtifactKind(value) {
+  return value === "raw" || value === "insight" || value === "profile" || value === "procedure";
+}
+function validateScope(value) {
+  if (value === void 0) return { ok: true, errors: [] };
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, errors: ["scope must be an object when present"] };
+  }
+  const scope = value;
+  const errors = [];
+  const allowed = /* @__PURE__ */ new Set(["sessionId", "projectId", "userId", "tenantId"]);
+  for (const key of Object.keys(scope)) {
+    if (!allowed.has(key)) errors.push(`scope.${key} is not part of AgenticMemoryScope`);
+  }
+  for (const key of allowed) {
+    if (scope[key] !== void 0 && (typeof scope[key] !== "string" || scope[key].length === 0)) {
+      errors.push(`scope.${key} must be a non-empty string when present`);
     }
-  );
+  }
+  if (errors.length > 0) return { ok: false, errors };
   return {
-    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
-    )
+    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 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
-    }
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function ownKeys(value) {
+  return Object.keys(value).sort();
+}
+function assertExactKeys(value, expected, label) {
+  const actual = ownKeys(value);
+  const want = [...expected].sort();
+  if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+    throw new TypeError(`${label}: unexpected fields ${actual.join(",")}`);
+  }
+}
+function assertAgenticMemoryRecordCodecShape(value) {
+  if (!isPlainRecord(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+  }
+  assertNoSymbolKeys(value, "agenticMemoryRecordFrame.record");
+  assertExactKeys(
+    value,
+    value.scope === void 0 ? ["artifactKind", "fragment", "id", "kind", "persistenceLevel"] : ["artifactKind", "fragment", "id", "kind", "persistenceLevel", "scope"],
+    "agenticMemoryRecordFrame.record"
   );
-  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
-    )
-  };
+  const fragment = value.fragment;
+  if (!isPlainRecord(fragment)) {
+    throw new TypeError("agenticMemoryRecordFrame: fragment must be an object");
+  }
+  assertNoSymbolKeys(fragment, "agenticMemoryRecordFrame.record.fragment");
+  assertExactKeys(
+    fragment,
+    [
+      "id",
+      "payload",
+      "tNs",
+      ...fragment.validFrom === void 0 ? [] : ["validFrom"],
+      ...fragment.validTo === void 0 ? [] : ["validTo"],
+      "confidence",
+      "tags",
+      "sources",
+      ...fragment.embedding === void 0 ? [] : ["embedding"],
+      ...fragment.parentFragmentId === void 0 ? [] : ["parentFragmentId"],
+      ...fragment.provenance === void 0 ? [] : ["provenance"]
+    ],
+    "agenticMemoryRecordFrame.record.fragment"
+  );
+  assertStrictJsonValue(fragment.tags, "record.fragment.tags");
+  assertStrictJsonValue(fragment.sources, "record.fragment.sources");
+  if (fragment.embedding !== void 0) {
+    assertStrictJsonValue(fragment.embedding, "record.fragment.embedding");
+  }
+  if (value.scope !== void 0) assertScopeFrame(value.scope);
+}
+function assertNoSymbolKeys(value, label) {
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError(`${label}: unexpected symbol fields`);
+  }
+}
+function decimalBigIntString(value, label) {
+  const out = value.toString(10);
+  if (!/^-?(0|[1-9]\d*)$/.test(out)) {
+    throw new TypeError(`${label} must encode as a canonical decimal bigint string`);
+  }
+  return out;
+}
+function parseDecimalBigInt(value, label) {
+  if (typeof value !== "string" || !/^(0|-?[1-9]\d*)$/.test(value)) {
+    throw new TypeError(`${label} must be a canonical decimal bigint string`);
+  }
+  return BigInt(value);
+}
+function assertStrictJsonValue(value, label) {
+  try {
+    strictJsonCodec.encode(value);
+    return value;
+  } catch (error) {
+    throw new TypeError(`${label} must be strict JSON: ${errorMessage(error)}`);
+  }
+}
+function assertScopeFrame(value) {
+  if (!isPlainRecord(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: scope must be an object when present");
+  }
+  assertStrictJsonValue(value, "record.scope");
+  const validation = validateScope(value);
+  if (!validation.ok || validation.scope === void 0) {
+    throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
+  }
+  assertExactKeys(
+    value,
+    [
+      ...value.sessionId === void 0 ? [] : ["sessionId"],
+      ...value.projectId === void 0 ? [] : ["projectId"],
+      ...value.userId === void 0 ? [] : ["userId"],
+      ...value.tenantId === void 0 ? [] : ["tenantId"]
+    ],
+    "agenticMemoryRecordFrame.record.scope"
+  );
+  return validation.scope;
+}
+function assertKindValue(value) {
+  if (!isAgenticMemoryKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid memory kind");
+  }
+  return value;
+}
+function assertPersistenceLevelValue(value) {
+  if (!isAgenticMemoryPersistenceLevel(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
+  }
+  return value;
+}
+function assertArtifactKindValue(value) {
+  if (!isAgenticMemoryArtifactKind(value)) {
+    throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
+  }
+  return value;
+}
+function assertNonEmptyString(value, label) {
+  if (!isNonEmptyString(value)) throw new TypeError(`${label} must be a non-empty string`);
+  return value;
+}
+function assertString(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+  return value;
+}
+function assertConfidence(value, label) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new TypeError(`${label} must be a finite number in [0, 1]`);
+  }
+  return value;
+}
+function assertStringArray(value, label) {
+  if (!isDenseArrayOf(value, (item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a readonly string array`);
+  }
+  return Object.freeze([...value]);
+}
+function assertFiniteNumberArray(value, label) {
+  if (!isDenseArrayOf(value, (item) => Number.isFinite(item))) {
+    throw new TypeError(`${label} must be a finite number array`);
+  }
+  return Object.freeze([...value]);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isDenseArrayOf(value, predicate) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+  }
+  return true;
+}
+function freezeError(error) {
+  return Object.freeze({
+    ...error,
+    ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) }
+  });
+}
+function safeArrayLength(value) {
+  try {
+    return value.length;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
+
+// src/solutions/agentic-memory-projection.ts
 function solutionProjection(graph, snapshot, name, factory, select) {
   return graph.node(
     [snapshot],
@@ -642,569 +652,187 @@ function agenticMemoryRecordProjection(graph, records, name) {
     }
   );
 }
-function validateAndProjectKgDrafts(value, records) {
-  const assertions = [];
-  const errors = [];
-  let invalidDrafts = 0;
-  if (!Array.isArray(value)) {
-    return {
-      assertions,
-      invalidDrafts: 1,
-      errors: [
-        {
-          code: "invalid-drafts-input",
-          message: "agenticMemoryKgProjectionBundle: drafts input must be an array",
-          draft: value
-        }
-      ]
-    };
-  }
-  const length = safeArrayLength(value);
-  if (length === void 0) {
-    return {
-      assertions,
-      invalidDrafts: 1,
-      errors: [
-        {
-          code: "invalid-drafts-input",
-          message: "agenticMemoryKgProjectionBundle: drafts input length could not be read",
-          draft: value
-        }
-      ]
-    };
-  }
-  const recordById = new Map(records.map((record) => [record.id, record]));
-  const fragmentToRecord = new Map(records.map((record) => [record.fragment.id, record.id]));
-  const seenAssertions = /* @__PURE__ */ new Set();
-  for (let i = 0; i < length; i += 1) {
-    let raw;
-    try {
-      raw = value[i];
-      const result = validateKgDraft(raw, i);
-      if (result.errors.length > 0 || result.draft === void 0) {
-        invalidDrafts += 1;
-        errors.push(...result.errors);
-        continue;
-      }
-      const draft = result.draft;
-      if (seenAssertions.has(draft.id)) {
-        invalidDrafts += 1;
-        errors.push({
-          code: "duplicate-assertion-id",
-          message: "agenticMemoryKgProjectionBundle: duplicate assertion id",
-          index: i,
-          assertionId: draft.id,
-          recordId: draft.recordId,
-          fragmentId: draft.fragmentId,
-          draft: raw,
-          validationErrors: [`duplicate assertion id '${draft.id}'`]
-        });
-        continue;
-      }
-      const record = recordById.get(draft.recordId);
-      if (record === void 0) {
-        invalidDrafts += 1;
-        errors.push({
-          code: "missing-record-ref",
-          message: "agenticMemoryKgProjectionBundle: draft references a missing record",
-          index: i,
-          assertionId: draft.id,
-          recordId: draft.recordId,
-          fragmentId: draft.fragmentId,
-          draft: raw,
-          validationErrors: [`record '${draft.recordId}' is not projected`]
-        });
-        continue;
-      }
-      const owner = fragmentToRecord.get(draft.fragmentId);
-      if (owner === void 0) {
-        invalidDrafts += 1;
-        errors.push({
-          code: "missing-fragment-ref",
-          message: "agenticMemoryKgProjectionBundle: draft references a missing fragment",
-          index: i,
-          assertionId: draft.id,
-          recordId: draft.recordId,
-          fragmentId: draft.fragmentId,
-          draft: raw,
-          validationErrors: [`fragment '${draft.fragmentId}' is not projected`]
-        });
-        continue;
-      }
-      if (owner !== draft.recordId || record.fragment.id !== draft.fragmentId) {
-        invalidDrafts += 1;
-        errors.push({
-          code: "fragment-record-mismatch",
-          message: "agenticMemoryKgProjectionBundle: draft record and fragment refs disagree",
-          index: i,
-          assertionId: draft.id,
-          recordId: draft.recordId,
-          fragmentId: draft.fragmentId,
-          draft: raw,
-          validationErrors: [
-            `fragment '${draft.fragmentId}' belongs to record '${owner}', not '${draft.recordId}'`
-          ]
-        });
-        continue;
-      }
-      seenAssertions.add(draft.id);
-      assertions.push(
-        Object.freeze({
-          id: draft.id,
-          recordId: draft.recordId,
-          fragmentId: draft.fragmentId,
-          subject: draft.subject,
-          predicate: draft.predicate,
-          object: draft.object,
-          ...draft.confidence === void 0 ? {} : { confidence: draft.confidence },
-          sources: Object.freeze(draft.sources ?? [draft.fragmentId]),
-          ...draft.provenance === void 0 ? {} : { provenance: draft.provenance }
-        })
-      );
-    } catch (error) {
-      invalidDrafts += 1;
-      errors.push({
-        code: "invalid-draft",
-        message: `agenticMemoryKgProjectionBundle: draft access failed: ${errorMessage(error)}`,
-        index: i,
-        draft: raw,
-        validationErrors: ["draft access failed"]
-      });
-    }
-  }
-  return { assertions, errors, invalidDrafts };
-}
-function validateKgDraft(value, index) {
-  const errors = [];
-  if (!isPlainRecord(value)) {
-    return {
-      errors: [
-        {
-          code: "invalid-draft",
-          message: "agenticMemoryKgProjectionBundle: draft must be an object",
-          index,
-          draft: value
-        }
-      ]
-    };
-  }
-  const raw = value;
-  const id = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : void 0;
-  const recordId = typeof raw.recordId === "string" && raw.recordId.length > 0 ? raw.recordId : void 0;
-  const fragmentId = typeof raw.fragmentId === "string" && raw.fragmentId.length > 0 ? raw.fragmentId : void 0;
-  const subject = validateAssertionSubject(raw.subject);
-  const object = validateAssertionObject(raw.object);
-  const shapeErrors = [];
-  if (id === void 0) shapeErrors.push("draft.id must be a non-empty string");
-  if (recordId === void 0) {
-    shapeErrors.push("draft.recordId must be a non-empty string");
-  }
-  if (fragmentId === void 0) {
-    shapeErrors.push("draft.fragmentId must be a non-empty string");
-  }
-  shapeErrors.push(...subject.errors);
-  if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
-    shapeErrors.push("draft.predicate must be a non-empty string");
-  }
-  shapeErrors.push(...object.errors);
-  if (raw.confidence !== void 0 && (!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)) {
-    shapeErrors.push("draft.confidence must be a finite number in [0, 1]");
-  }
-  if (raw.sources !== void 0 && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
-    shapeErrors.push("draft.sources must be a readonly string array");
-  }
-  if (raw.provenance !== void 0 && typeof raw.provenance !== "string") {
-    shapeErrors.push("draft.provenance must be a string when present");
-  }
-  if (shapeErrors.length > 0) errors.push(kgShapeError(index, value, ...shapeErrors));
-  if (errors.length > 0 || id === void 0 || recordId === void 0 || fragmentId === void 0) {
-    return { errors };
-  }
-  return {
-    draft: Object.freeze({
-      id,
-      recordId,
-      fragmentId,
-      subject: subject.subject,
-      predicate: raw.predicate,
-      object: object.object,
-      ...raw.confidence === void 0 ? {} : { confidence: raw.confidence },
-      ...raw.sources === void 0 ? {} : { sources: Object.freeze([...raw.sources]) },
-      ...raw.provenance === void 0 ? {} : { provenance: raw.provenance }
-    }),
-    errors
-  };
-}
-function validateAssertionSubject(value) {
-  if (!isPlainRecord(value)) return { errors: ["subject must be an object"] };
-  const id = value.id;
-  const type = value.type;
-  const errors = [];
-  if (typeof id !== "string" || id.length === 0) errors.push("subject.id must be non-empty");
-  if (type !== void 0 && (typeof type !== "string" || type.length === 0)) {
-    errors.push("subject.type must be a non-empty string when present");
-  }
-  if (errors.length > 0) return { errors };
-  return {
-    subject: Object.freeze({
-      id,
-      ...type === void 0 ? {} : { type }
-    }),
-    errors
-  };
-}
-function validateAssertionObject(value) {
-  if (!isPlainRecord(value)) return { errors: ["object must be an object"] };
-  const kind = value.kind;
-  const errors = [];
-  if (kind === "entity") {
-    if (typeof value.id !== "string" || value.id.length === 0) {
-      errors.push("object.id must be non-empty for entity objects");
-    }
-    if (value.type !== void 0 && (typeof value.type !== "string" || value.type.length === 0)) {
-      errors.push("object.type must be a non-empty string when present");
-    }
-    if (Object.hasOwn(value, "value")) errors.push("entity object must not include value");
-    if (errors.length > 0) return { errors };
-    return {
-      object: Object.freeze({
-        kind: "entity",
-        id: value.id,
-        ...value.type === void 0 ? {} : { type: value.type }
-      }),
-      errors
-    };
-  }
-  if (kind === "value") {
-    if (!Object.hasOwn(value, "value")) errors.push("value object must include value");
-    else {
-      try {
-        assertStrictJsonValue(value.value, "object.value");
-      } catch (error) {
-        errors.push(errorMessage(error));
-      }
-    }
-    if (value.valueType !== void 0 && (typeof value.valueType !== "string" || value.valueType.length === 0)) {
-      errors.push("object.valueType must be a non-empty string when present");
-    }
-    if (Object.hasOwn(value, "id")) errors.push("value object must not include id");
-    if (errors.length > 0) return { errors };
-    return {
-      object: Object.freeze({
-        kind: "value",
-        value: value.value,
-        ...value.valueType === void 0 ? {} : { valueType: value.valueType }
-      }),
-      errors
-    };
-  }
-  return { errors: ["object.kind must be entity or value"] };
-}
-function kgShapeError(index, draft, ...validationErrors) {
-  return {
-    code: "invalid-assertion-shape",
-    message: "agenticMemoryKgProjectionBundle: draft assertion shape is invalid",
-    index,
-    draft,
-    validationErrors: Object.freeze([...validationErrors])
-  };
-}
-function kgErrorFromRecordError(error) {
-  return {
-    ...error,
-    code: error.code
-  };
-}
-function fragmentFrame(fragment) {
-  return Object.freeze({
-    id: fragment.id,
-    payload: fragment.payload,
-    tNs: decimalBigIntString(fragment.tNs, "fragment.tNs"),
-    ...fragment.validFrom === void 0 ? {} : { validFrom: decimalBigIntString(fragment.validFrom, "fragment.validFrom") },
-    ...fragment.validTo === void 0 ? {} : { validTo: decimalBigIntString(fragment.validTo, "fragment.validTo") },
-    confidence: fragment.confidence,
-    tags: Object.freeze([...fragment.tags]),
-    sources: Object.freeze([...fragment.sources]),
-    ...fragment.embedding === void 0 ? {} : { embedding: Object.freeze([...fragment.embedding]) },
-    ...fragment.parentFragmentId === void 0 ? {} : { parentFragmentId: fragment.parentFragmentId },
-    ...fragment.provenance === void 0 ? {} : { provenance: fragment.provenance }
+
+// 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
   });
-}
-function recordFromFrame(frame) {
-  const fragment = frame.record.fragment;
-  const record = {
-    id: assertNonEmptyString(frame.record.id, "record.id"),
-    kind: assertKindValue(frame.record.kind),
-    persistenceLevel: assertPersistenceLevelValue(frame.record.persistenceLevel),
-    artifactKind: assertArtifactKindValue(frame.record.artifactKind),
-    ...frame.record.scope === void 0 ? {} : { scope: assertScopeFrame(frame.record.scope) },
-    fragment: {
-      id: assertNonEmptyString(fragment.id, "fragment.id"),
-      payload: assertStrictJsonValue(fragment.payload, "fragment.payload"),
-      tNs: parseDecimalBigInt(fragment.tNs, "fragment.tNs"),
-      ...fragment.validFrom === void 0 ? {} : { validFrom: parseDecimalBigInt(fragment.validFrom, "fragment.validFrom") },
-      ...fragment.validTo === void 0 ? {} : { validTo: parseDecimalBigInt(fragment.validTo, "fragment.validTo") },
-      confidence: assertConfidence(fragment.confidence, "fragment.confidence"),
-      tags: assertStringArray(fragment.tags, "fragment.tags"),
-      sources: assertStringArray(fragment.sources, "fragment.sources"),
-      ...fragment.embedding === void 0 ? {} : { embedding: assertFiniteNumberArray(fragment.embedding, "fragment.embedding") },
-      ...fragment.parentFragmentId === void 0 ? {} : {
-        parentFragmentId: assertNonEmptyString(fragment.parentFragmentId, "parentFragmentId")
-      },
-      ...fragment.provenance === void 0 ? {} : { provenance: assertString(fragment.provenance, "provenance") }
-    }
-  };
-  const result = validateAndSnapshotRecord(record, 0);
-  if (result.errors.length > 0 || result.record === void 0) {
-    throw new TypeError(
-      `agenticMemoryRecordFrame: decoded record is invalid: ${result.errors.flatMap((error) => error.validationErrors ?? [error.message]).join("; ")}`
-    );
-  }
-  return result.record;
-}
-function projectRetention(value, records) {
-  const byId = new Map(records.map((record) => [record.id, record]));
-  const view = new Map(records.map((record) => [record.id, record]));
-  const requests = [];
-  const errors = [];
-  let validCommands = 0;
-  let invalidCommands = 0;
-  if (!Array.isArray(value)) {
-    return {
-      activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
-      archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
-      consolidationRequests: requests,
-      validCommands,
-      invalidCommands: 1,
-      errors: [
-        {
-          code: "invalid-commands-input",
-          message: "agenticMemoryRetentionBundle: commands input must be an array",
-          command: value
-        }
-      ]
-    };
-  }
-  const length = safeArrayLength(value);
-  if (length === void 0) {
-    return {
-      activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
-      archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
-      consolidationRequests: requests,
-      validCommands,
-      invalidCommands: 1,
-      errors: [
-        {
-          code: "invalid-commands-input",
-          message: "agenticMemoryRetentionBundle: commands input length could not be read",
-          command: value
-        }
-      ]
-    };
-  }
-  const seenCommands = /* @__PURE__ */ new Set();
-  for (let i = 0; i < length; i += 1) {
-    let raw;
-    try {
-      raw = value[i];
-      const result = validateRetentionCommand(raw, i);
-      if (result.errors.length > 0 || result.command === void 0) {
-        invalidCommands += 1;
-        errors.push(...result.errors);
-        continue;
-      }
-      const command = result.command;
-      if (seenCommands.has(command.id)) {
-        invalidCommands += 1;
-        errors.push({
-          code: "duplicate-command-id",
-          message: "agenticMemoryRetentionBundle: duplicate command id",
-          index: i,
-          commandId: command.id,
-          command: raw,
-          validationErrors: [`duplicate command id '${command.id}'`]
-        });
-        continue;
-      }
-      const missing = retentionMissingRecords(command, byId);
-      if (missing.length > 0) {
-        invalidCommands += 1;
-        errors.push({
-          code: "missing-record-ref",
-          message: "agenticMemoryRetentionBundle: command references missing records",
-          index: i,
-          commandId: command.id,
-          recordId: "recordId" in command ? command.recordId : void 0,
-          recordIds: Object.freeze(missing),
-          command: raw,
-          validationErrors: Object.freeze(missing.map((id) => `record '${id}' is not projected`))
-        });
-        continue;
-      }
-      seenCommands.add(command.id);
-      validCommands += 1;
-      applyRetentionCommand(command, byId, view, requests);
-    } catch (error) {
-      invalidCommands += 1;
-      errors.push({
-        code: "invalid-command",
-        message: `agenticMemoryRetentionBundle: command access failed: ${errorMessage(error)}`,
-        index: i,
-        command: raw,
-        validationErrors: ["command access failed"]
-      });
-    }
-  }
-  const projected = records.map((record) => view.get(record.id) ?? record);
+  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);
@@ -1669,781 +1355,1655 @@ function packContext(contextValue, textsValue, policyValue, evaluation) {
     cursor
   });
 }
-function validatePackingContext(value, errors) {
+function validatePackingContext(value, errors) {
+  if (!isPlainRecord(value)) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      value
+    });
+    return void 0;
+  }
+  let entriesValue;
+  try {
+    entriesValue = value.entries;
+  } catch (error) {
+    errors.push({
+      code: "invalid-context",
+      message: `agenticMemoryContextPackingBundle: context entries access failed: ${errorMessage(error)}`,
+      value,
+      validationErrors: ["context entries access failed"]
+    });
+    return void 0;
+  }
+  if (!Array.isArray(entriesValue)) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      value,
+      validationErrors: ["context.entries must be an array"]
+    });
+    return void 0;
+  }
+  const length = safeArrayLength(entriesValue);
+  if (length === void 0) {
+    errors.push({
+      code: "invalid-context",
+      message: "agenticMemoryContextPackingBundle: context entries length could not be read",
+      value,
+      validationErrors: ["context.entries length could not be read"]
+    });
+    return void 0;
+  }
+  const entries = [];
+  for (let i = 0; i < length; i += 1) {
+    let raw;
+    try {
+      raw = entriesValue[i];
+      if (!isPlainRecord(raw) || !isNonEmptyString(raw.fragmentId)) {
+        errors.push({
+          code: "invalid-context",
+          message: "agenticMemoryContextPackingBundle: context entry is invalid",
+          index: i,
+          value: raw,
+          validationErrors: ["context entry fragmentId must be a non-empty string"]
+        });
+        continue;
+      }
+      const record = validateRecordMetadata(raw.record);
+      if (!record.ok) {
+        errors.push({
+          code: "invalid-context",
+          message: "agenticMemoryContextPackingBundle: context entry record metadata is invalid",
+          index: i,
+          fragmentId: raw.fragmentId,
+          value: raw,
+          validationErrors: Object.freeze(record.errors)
+        });
+        continue;
+      }
+      entries.push(
+        Object.freeze({
+          fragmentId: raw.fragmentId,
+          ...record.metadata === void 0 ? {} : { record: record.metadata }
+        })
+      );
+    } catch (error) {
+      errors.push({
+        code: "invalid-context",
+        message: `agenticMemoryContextPackingBundle: context entry access failed: ${errorMessage(error)}`,
+        index: i,
+        value: raw,
+        validationErrors: ["context entry access failed"]
+      });
+    }
+  }
+  return Object.freeze({
+    entries: Object.freeze(entries)
+  });
+}
+function validateContextTexts(value, errors) {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(value)) {
+    errors.push({
+      code: "invalid-texts-input",
+      message: "agenticMemoryContextPackingBundle: texts input must be an array",
+      value
+    });
+    return out;
+  }
+  const length = safeArrayLength(value);
+  if (length === void 0) {
+    errors.push({
+      code: "invalid-texts-input",
+      message: "agenticMemoryContextPackingBundle: texts input length could not be read",
+      value
+    });
+    return out;
+  }
+  for (let i = 0; i < length; i += 1) {
+    try {
+      const raw = value[i];
+      const result = validateContextText(raw, i);
+      if (result.error !== void 0) {
+        errors.push(result.error);
+        continue;
+      }
+      if (result.text === void 0) {
+        errors.push({
+          code: "invalid-text",
+          message: "agenticMemoryContextPackingBundle: text fact is invalid",
+          index: i,
+          value: raw,
+          validationErrors: ["text validation returned no fact"]
+        });
+        continue;
+      }
+      if (out.has(result.text.fragmentId)) {
+        errors.push({
+          code: "duplicate-text-fragment-id",
+          message: "agenticMemoryContextPackingBundle: duplicate text fragment id",
+          index: i,
+          fragmentId: result.text.fragmentId,
+          value: raw,
+          validationErrors: [`duplicate text fragment id '${result.text.fragmentId}'`]
+        });
+        continue;
+      }
+      out.set(result.text.fragmentId, result.text);
+    } catch (error) {
+      errors.push({
+        code: "invalid-text",
+        message: `agenticMemoryContextPackingBundle: text access failed: ${errorMessage(error)}`,
+        index: i,
+        validationErrors: ["text access failed"]
+      });
+    }
+  }
+  return out;
+}
+function validateContextText(value, index) {
+  if (!isPlainRecord(value)) {
+    return {
+      error: {
+        code: "invalid-text",
+        message: "agenticMemoryContextPackingBundle: text fact must be an object",
+        index,
+        value
+      }
+    };
+  }
+  const errors = [];
+  if (!isNonEmptyString(value.fragmentId)) errors.push("fragmentId must be a non-empty string");
+  if (typeof value.text !== "string") errors.push("text must be a string");
+  if (value.cost !== void 0 && (typeof value.cost !== "number" || !Number.isFinite(value.cost) || value.cost < 0)) {
+    errors.push("cost must be a finite number >= 0");
+  }
+  if (value.metadata !== void 0) {
+    try {
+      if (!isPlainRecord(value.metadata)) {
+        throw new TypeError("metadata must be a plain object when present");
+      }
+      assertStrictJsonValue(value.metadata, "metadata");
+    } catch (error) {
+      errors.push(errorMessage(error));
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      error: {
+        code: "invalid-text",
+        message: "agenticMemoryContextPackingBundle: text fact is invalid",
+        index,
+        fragmentId: typeof value.fragmentId === "string" ? value.fragmentId : void 0,
+        value,
+        validationErrors: Object.freeze(errors)
+      }
+    };
+  }
+  return {
+    text: Object.freeze({
+      fragmentId: value.fragmentId,
+      text: value.text,
+      ...value.cost === void 0 ? {} : { cost: value.cost },
+      ...value.metadata === void 0 ? {} : { metadata: Object.freeze({ ...value.metadata }) }
+    })
+  };
+}
+function validatePackingPolicy(value, errors) {
   if (!isPlainRecord(value)) {
     errors.push({
-      code: "invalid-context",
-      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      code: "invalid-policy",
+      message: "agenticMemoryContextPackingBundle: policy must be an object",
       value
     });
     return void 0;
   }
-  let entriesValue;
+  const validation = [];
+  let maxEntries;
+  let maxChars;
+  let maxCost;
+  let includeMetadata;
   try {
-    entriesValue = value.entries;
+    maxEntries = value.maxEntries;
+    maxChars = value.maxChars;
+    maxCost = value.maxCost;
+    includeMetadata = value.includeMetadata;
   } catch (error) {
     errors.push({
-      code: "invalid-context",
-      message: `agenticMemoryContextPackingBundle: context entries access failed: ${errorMessage(error)}`,
+      code: "invalid-policy",
+      message: `agenticMemoryContextPackingBundle: policy access failed: ${errorMessage(error)}`,
       value,
-      validationErrors: ["context entries access failed"]
+      validationErrors: ["policy access failed"]
     });
     return void 0;
   }
-  if (!Array.isArray(entriesValue)) {
+  if (maxEntries !== void 0 && (typeof maxEntries !== "number" || !Number.isSafeInteger(maxEntries) || maxEntries < 0)) {
+    validation.push("maxEntries must be a safe integer >= 0");
+  }
+  if (maxChars !== void 0 && (typeof maxChars !== "number" || !Number.isSafeInteger(maxChars) || maxChars < 0)) {
+    validation.push("maxChars must be a safe integer >= 0");
+  }
+  if (maxCost !== void 0 && (typeof maxCost !== "number" || !Number.isFinite(maxCost) || maxCost < 0)) {
+    validation.push("maxCost must be a finite number >= 0");
+  }
+  if (includeMetadata !== void 0 && typeof includeMetadata !== "boolean") {
+    validation.push("includeMetadata must be a boolean when present");
+  }
+  if (validation.length > 0) {
     errors.push({
-      code: "invalid-context",
-      message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+      code: "invalid-policy",
+      message: "agenticMemoryContextPackingBundle: policy is invalid",
       value,
-      validationErrors: ["context.entries must be an array"]
+      validationErrors: Object.freeze(validation)
     });
     return void 0;
   }
-  const length = safeArrayLength(entriesValue);
+  return Object.freeze({
+    ...maxEntries === void 0 ? {} : { maxEntries },
+    ...maxChars === void 0 ? {} : { maxChars },
+    ...maxCost === void 0 ? {} : { maxCost },
+    ...includeMetadata === void 0 ? {} : { includeMetadata }
+  });
+}
+
+// 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 = [];
+  let invalidDrafts = 0;
+  if (!Array.isArray(value)) {
+    return {
+      assertions,
+      invalidDrafts: 1,
+      errors: [
+        {
+          code: "invalid-drafts-input",
+          message: "agenticMemoryKgProjectionBundle: drafts input must be an array",
+          draft: value
+        }
+      ]
+    };
+  }
+  const length = safeArrayLength(value);
   if (length === void 0) {
-    errors.push({
-      code: "invalid-context",
-      message: "agenticMemoryContextPackingBundle: context entries length could not be read",
-      value,
-      validationErrors: ["context.entries length could not be read"]
-    });
-    return void 0;
+    return {
+      assertions,
+      invalidDrafts: 1,
+      errors: [
+        {
+          code: "invalid-drafts-input",
+          message: "agenticMemoryKgProjectionBundle: drafts input length could not be read",
+          draft: value
+        }
+      ]
+    };
   }
-  const entries = [];
+  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 = entriesValue[i];
-      if (!isPlainRecord(raw) || !isNonEmptyString(raw.fragmentId)) {
+      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: "invalid-context",
-          message: "agenticMemoryContextPackingBundle: context entry is invalid",
+          code: "duplicate-assertion-id",
+          message: "agenticMemoryKgProjectionBundle: duplicate assertion id",
           index: i,
-          value: raw,
-          validationErrors: ["context entry fragmentId must be a non-empty string"]
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`duplicate assertion id '${draft.id}'`]
         });
         continue;
       }
-      const record = validateRecordMetadata(raw.record);
-      if (!record.ok) {
+      const record = recordById.get(draft.recordId);
+      if (record === void 0) {
+        invalidDrafts += 1;
         errors.push({
-          code: "invalid-context",
-          message: "agenticMemoryContextPackingBundle: context entry record metadata is invalid",
+          code: "missing-record-ref",
+          message: "agenticMemoryKgProjectionBundle: draft references a missing record",
           index: i,
-          fragmentId: raw.fragmentId,
-          value: raw,
-          validationErrors: Object.freeze(record.errors)
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`record '${draft.recordId}' is not projected`]
         });
         continue;
       }
-      entries.push(
-        Object.freeze({
-          fragmentId: raw.fragmentId,
-          ...record.metadata === void 0 ? {} : { record: record.metadata }
-        })
-      );
-    } catch (error) {
-      errors.push({
-        code: "invalid-context",
-        message: `agenticMemoryContextPackingBundle: context entry access failed: ${errorMessage(error)}`,
-        index: i,
-        value: raw,
-        validationErrors: ["context entry access failed"]
-      });
-    }
-  }
-  return Object.freeze({
-    entries: Object.freeze(entries)
-  });
-}
-function validateContextTexts(value, errors) {
-  const out = /* @__PURE__ */ new Map();
-  if (!Array.isArray(value)) {
-    errors.push({
-      code: "invalid-texts-input",
-      message: "agenticMemoryContextPackingBundle: texts input must be an array",
-      value
-    });
-    return out;
-  }
-  const length = safeArrayLength(value);
-  if (length === void 0) {
-    errors.push({
-      code: "invalid-texts-input",
-      message: "agenticMemoryContextPackingBundle: texts input length could not be read",
-      value
-    });
-    return out;
-  }
-  for (let i = 0; i < length; i += 1) {
-    try {
-      const raw = value[i];
-      const result = validateContextText(raw, i);
-      if (result.error !== void 0) {
-        errors.push(result.error);
-        continue;
-      }
-      if (result.text === void 0) {
+      const owner = fragmentToRecord.get(draft.fragmentId);
+      if (owner === void 0) {
+        invalidDrafts += 1;
         errors.push({
-          code: "invalid-text",
-          message: "agenticMemoryContextPackingBundle: text fact is invalid",
+          code: "missing-fragment-ref",
+          message: "agenticMemoryKgProjectionBundle: draft references a missing fragment",
           index: i,
-          value: raw,
-          validationErrors: ["text validation returned no fact"]
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [`fragment '${draft.fragmentId}' is not projected`]
         });
         continue;
       }
-      if (out.has(result.text.fragmentId)) {
+      if (owner !== draft.recordId || record.fragment.id !== draft.fragmentId) {
+        invalidDrafts += 1;
         errors.push({
-          code: "duplicate-text-fragment-id",
-          message: "agenticMemoryContextPackingBundle: duplicate text fragment id",
+          code: "fragment-record-mismatch",
+          message: "agenticMemoryKgProjectionBundle: draft record and fragment refs disagree",
           index: i,
-          fragmentId: result.text.fragmentId,
-          value: raw,
-          validationErrors: [`duplicate text fragment id '${result.text.fragmentId}'`]
+          assertionId: draft.id,
+          recordId: draft.recordId,
+          fragmentId: draft.fragmentId,
+          draft: raw,
+          validationErrors: [
+            `fragment '${draft.fragmentId}' belongs to record '${owner}', not '${draft.recordId}'`
+          ]
         });
         continue;
       }
-      out.set(result.text.fragmentId, result.text);
+      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-text",
-        message: `agenticMemoryContextPackingBundle: text access failed: ${errorMessage(error)}`,
+        code: "invalid-draft",
+        message: `agenticMemoryKgProjectionBundle: draft access failed: ${errorMessage(error)}`,
         index: i,
-        validationErrors: ["text access failed"]
+        draft: raw,
+        validationErrors: ["draft access failed"]
       });
     }
   }
-  return out;
-}
-function validateContextText(value, index) {
-  if (!isPlainRecord(value)) {
-    return {
-      error: {
-        code: "invalid-text",
-        message: "agenticMemoryContextPackingBundle: text fact must be an object",
-        index,
-        value
-      }
-    };
-  }
-  const errors = [];
-  if (!isNonEmptyString(value.fragmentId)) errors.push("fragmentId must be a non-empty string");
-  if (typeof value.text !== "string") errors.push("text must be a string");
-  if (value.cost !== void 0 && (typeof value.cost !== "number" || !Number.isFinite(value.cost) || value.cost < 0)) {
-    errors.push("cost must be a finite number >= 0");
-  }
-  if (value.metadata !== void 0) {
-    try {
-      if (!isPlainRecord(value.metadata)) {
-        throw new TypeError("metadata must be a plain object when present");
-      }
-      assertStrictJsonValue(value.metadata, "metadata");
-    } catch (error) {
-      errors.push(errorMessage(error));
-    }
-  }
-  if (errors.length > 0) {
-    return {
-      error: {
-        code: "invalid-text",
-        message: "agenticMemoryContextPackingBundle: text fact is invalid",
-        index,
-        fragmentId: typeof value.fragmentId === "string" ? value.fragmentId : void 0,
-        value,
-        validationErrors: Object.freeze(errors)
-      }
-    };
-  }
-  return {
-    text: Object.freeze({
-      fragmentId: value.fragmentId,
-      text: value.text,
-      ...value.cost === void 0 ? {} : { cost: value.cost },
-      ...value.metadata === void 0 ? {} : { metadata: Object.freeze({ ...value.metadata }) }
-    })
-  };
+  return { assertions, errors, invalidDrafts };
 }
-function validatePackingPolicy(value, errors) {
+function validateKgDraft(value, index) {
+  const errors = [];
   if (!isPlainRecord(value)) {
-    errors.push({
-      code: "invalid-policy",
-      message: "agenticMemoryContextPackingBundle: policy must be an object",
-      value
-    });
-    return void 0;
+    return {
+      errors: [
+        {
+          code: "invalid-draft",
+          message: "agenticMemoryKgProjectionBundle: draft must be an object",
+          index,
+          draft: value
+        }
+      ]
+    };
   }
-  const validation = [];
-  let maxEntries;
-  let maxChars;
-  let maxCost;
-  let includeMetadata;
-  try {
-    maxEntries = value.maxEntries;
-    maxChars = value.maxChars;
-    maxCost = value.maxCost;
-    includeMetadata = value.includeMetadata;
-  } catch (error) {
-    errors.push({
-      code: "invalid-policy",
-      message: `agenticMemoryContextPackingBundle: policy access failed: ${errorMessage(error)}`,
-      value,
-      validationErrors: ["policy access failed"]
-    });
-    return void 0;
+  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 (maxEntries !== void 0 && (typeof maxEntries !== "number" || !Number.isSafeInteger(maxEntries) || maxEntries < 0)) {
-    validation.push("maxEntries must be a safe integer >= 0");
+  if (fragmentId === void 0) {
+    shapeErrors.push("draft.fragmentId must be a non-empty string");
   }
-  if (maxChars !== void 0 && (typeof maxChars !== "number" || !Number.isSafeInteger(maxChars) || maxChars < 0)) {
-    validation.push("maxChars must be a safe integer >= 0");
+  shapeErrors.push(...subject.errors);
+  if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
+    shapeErrors.push("draft.predicate must be a non-empty string");
   }
-  if (maxCost !== void 0 && (typeof maxCost !== "number" || !Number.isFinite(maxCost) || maxCost < 0)) {
-    validation.push("maxCost must be a finite number >= 0");
+  shapeErrors.push(...object.errors);
+  if (raw.confidence !== void 0 && (!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)) {
+    shapeErrors.push("draft.confidence must be a finite number in [0, 1]");
   }
-  if (includeMetadata !== void 0 && typeof includeMetadata !== "boolean") {
-    validation.push("includeMetadata must be a boolean when present");
+  if (raw.sources !== void 0 && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
+    shapeErrors.push("draft.sources must be a readonly string array");
   }
-  if (validation.length > 0) {
-    errors.push({
-      code: "invalid-policy",
-      message: "agenticMemoryContextPackingBundle: policy is invalid",
-      value,
-      validationErrors: Object.freeze(validation)
-    });
-    return void 0;
+  if (raw.provenance !== void 0 && typeof raw.provenance !== "string") {
+    shapeErrors.push("draft.provenance must be a string when present");
   }
-  return Object.freeze({
-    ...maxEntries === void 0 ? {} : { maxEntries },
-    ...maxChars === void 0 ? {} : { maxChars },
-    ...maxCost === void 0 ? {} : { maxCost },
-    ...includeMetadata === void 0 ? {} : { includeMetadata }
-  });
+  if (shapeErrors.length > 0) errors.push(kgShapeError(index, value, ...shapeErrors));
+  if (errors.length > 0 || id === void 0 || recordId === void 0 || fragmentId === void 0) {
+    return { errors };
+  }
+  return {
+    draft: Object.freeze({
+      id,
+      recordId,
+      fragmentId,
+      subject: subject.subject,
+      predicate: raw.predicate,
+      object: object.object,
+      ...raw.confidence === void 0 ? {} : { confidence: raw.confidence },
+      ...raw.sources === void 0 ? {} : { sources: Object.freeze([...raw.sources]) },
+      ...raw.provenance === void 0 ? {} : { provenance: raw.provenance }
+    }),
+    errors
+  };
 }
-function validateAndProjectRecords(value) {
-  const records = [];
-  const fragments = [];
-  const metadataByFragmentId = /* @__PURE__ */ Object.create(null);
+function validateAssertionSubject(value) {
+  if (!isPlainRecord(value)) return { errors: ["subject must be an object"] };
+  const id = value.id;
+  const type = value.type;
   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 };
+  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");
   }
-  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 };
+  if (errors.length > 0) return { errors };
+  return {
+    subject: Object.freeze({
+      id,
+      ...type === void 0 ? {} : { type }
+    }),
+    errors
+  };
+}
+function validateAssertionObject(value) {
+  if (!isPlainRecord(value)) return { errors: ["object must be an object"] };
+  const kind = value.kind;
+  const errors = [];
+  if (kind === "entity") {
+    if (typeof value.id !== "string" || value.id.length === 0) {
+      errors.push("object.id must be non-empty for entity objects");
+    }
+    if (value.type !== void 0 && (typeof value.type !== "string" || value.type.length === 0)) {
+      errors.push("object.type must be a non-empty string when present");
+    }
+    if (Object.hasOwn(value, "value")) errors.push("entity object must not include value");
+    if (errors.length > 0) return { errors };
+    return {
+      object: Object.freeze({
+        kind: "entity",
+        id: value.id,
+        ...value.type === void 0 ? {} : { type: value.type }
+      }),
+      errors
+    };
   }
-  for (let i = 0; i < length; i += 1) {
-    let raw;
-    try {
-      raw = value[i];
-    } catch (error) {
-      invalidRecordIndexes.add(i);
-      errors.push({
-        code: "invalid-record",
-        message: `agenticMemoryBundle: record access failed: ${errorMessage(error)}`,
-        index: i,
-        validationErrors: Object.freeze(["record access failed"])
-      });
-      continue;
+  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));
+      }
     }
-    const result = validateAndSnapshotRecord(raw, i);
-    if (result.errors.length > 0) {
-      invalidRecordIndexes.add(i);
-      errors.push(...result.errors);
-      continue;
+    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 (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}'`]
+    if (Object.hasOwn(value, "id")) errors.push("value object must not include id");
+    if (errors.length > 0) return { errors };
+    return {
+      object: Object.freeze({
+        kind: "value",
+        value: value.value,
+        ...value.valueType === void 0 ? {} : { valueType: value.valueType }
+      }),
+      errors
+    };
+  }
+  return { errors: ["object.kind must be entity or value"] };
+}
+function kgShapeError(index, draft, ...validationErrors) {
+  return {
+    code: "invalid-assertion-shape",
+    message: "agenticMemoryKgProjectionBundle: draft assertion shape is invalid",
+    index,
+    draft,
+    validationErrors: Object.freeze([...validationErrors])
+  };
+}
+function kgErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+
+// 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
       });
-      continue;
-    }
-    if (seenFragmentIds.has(result.record.fragment.id)) {
-      invalidRecordIndexes.add(i);
-      errors.push({
-        code: "duplicate-fragment-id",
-        message: "agenticMemoryBundle: duplicate fragment id",
-        index: i,
-        recordId: result.record.id,
-        fragmentId: result.record.fragment.id,
-        record: raw,
-        validationErrors: [`duplicate fragment id '${result.record.fragment.id}'`]
+      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
       });
-      continue;
+      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
     }
-    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 };
+  );
+  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 validateAndSnapshotRecord(value, index) {
-  try {
-    return validateAndSnapshotRecordInner(value, index);
-  } catch (error) {
+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-record",
-          message: `agenticMemoryBundle: record access failed: ${errorMessage(error)}`,
-          index,
-          record: value,
-          validationErrors: Object.freeze(["record access failed"])
+          code: "invalid-commands-input",
+          message: "agenticMemoryRetentionBundle: commands input must be an array",
+          command: value
         }
       ]
     };
   }
-}
-function validateAndSnapshotRecordInner(value, index) {
-  const errors = [];
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+  const length = safeArrayLength(value);
+  if (length === void 0) {
     return {
+      activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
+      archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
+      consolidationRequests: requests,
+      validCommands,
+      invalidCommands: 1,
       errors: [
         {
-          code: "invalid-record",
-          message: "agenticMemoryBundle: record must be an object",
-          index,
-          record: value
+          code: "invalid-commands-input",
+          message: "agenticMemoryRetentionBundle: commands input length could not be read",
+          command: value
         }
       ]
     };
   }
-  const record = value;
-  const recordId = typeof record.id === "string" ? record.id : void 0;
-  if (recordId === void 0 || recordId.length === 0) {
-    errors.push({
-      code: "invalid-record",
-      message: "agenticMemoryBundle: record.id must be a non-empty string",
-      index,
-      record: value,
-      validationErrors: ["record.id must be a non-empty string"]
-    });
-  }
-  if (!isAgenticMemoryKind(record.kind)) {
-    errors.push({
-      code: "invalid-record-kind",
-      message: "agenticMemoryBundle: record.kind is invalid",
-      index,
-      recordId,
-      record: value,
-      validationErrors: ["kind must be one of working, episodic, semantic, procedural, profile"]
-    });
-  }
-  if (!isAgenticMemoryPersistenceLevel(record.persistenceLevel)) {
-    errors.push({
-      code: "invalid-persistence-level",
-      message: "agenticMemoryBundle: record.persistenceLevel is invalid",
-      index,
-      recordId,
-      record: value,
-      validationErrors: [
-        "persistenceLevel must be one of turn, session, project, longTerm, permanent, archived"
-      ]
-    });
-  }
-  if (!isAgenticMemoryArtifactKind(record.artifactKind)) {
-    errors.push({
-      code: "invalid-artifact-kind",
-      message: "agenticMemoryBundle: record.artifactKind is invalid",
-      index,
-      recordId,
-      record: value,
-      validationErrors: ["artifactKind must be one of raw, insight, profile, procedure"]
-    });
-  }
-  const scopeValidation = validateScope(record.scope);
-  if (!scopeValidation.ok) {
-    errors.push({
-      code: "invalid-scope",
-      message: "agenticMemoryBundle: record.scope is invalid",
-      index,
-      recordId,
-      record: value,
-      validationErrors: Object.freeze(scopeValidation.errors)
-    });
-  }
-  const fragmentValidation = validateMemoryFragment(record.fragment);
-  if (!fragmentValidation.ok) {
-    errors.push({
-      code: "invalid-fragment",
-      message: "agenticMemoryBundle: record.fragment is invalid",
-      index,
-      recordId,
-      fragmentId: typeof record.fragment === "object" && record.fragment !== null && typeof record.fragment.id === "string" ? record.fragment.id : void 0,
-      record: value,
-      validationErrors: Object.freeze([...fragmentValidation.errors])
-    });
-  }
-  const forbiddenFields = [
-    "storageTier",
-    "storageKey",
-    "adapter",
-    "collection",
-    "collections",
-    "ttl",
-    "ttlMs",
-    "ttlNs",
-    "expiresAt",
-    "timer",
-    "scheduler",
-    "schedule",
-    "retentionTimer",
-    "consolidationSchedule",
-    "reflectionSchedule",
-    "llm",
-    "llmHandle",
-    "tool",
-    "toolHandle",
-    "runner",
-    "runnerHandle",
-    "restore",
-    "hydrate",
-    "hydration",
-    "graphMutation",
-    "protocol"
-  ];
-  const presentForbidden = forbiddenFields.filter((field) => Object.hasOwn(record, field));
-  if (presentForbidden.length > 0) {
-    errors.push({
-      code: "invalid-record",
-      message: "agenticMemoryBundle: record contains forbidden runtime/persistence fields",
-      index,
-      recordId,
-      record: value,
-      validationErrors: Object.freeze(
-        presentForbidden.map((field) => `${field} is not part of AgenticMemoryRecord`)
-      )
-    });
+  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"]
+      });
+    }
   }
-  if (errors.length > 0) return { errors };
-  const scope = scopeValidation.scope;
-  const fragment = snapshotFragment(record.fragment);
+  const projected = records.map((record) => view.get(record.id) ?? record);
   return {
-    record: Object.freeze({
-      id: recordId,
-      kind: record.kind,
-      persistenceLevel: record.persistenceLevel,
-      artifactKind: record.artifactKind,
-      ...scope === void 0 ? {} : { scope },
-      fragment
-    }),
-    errors
+    activeRecords: projected.filter((record) => record.persistenceLevel !== "archived"),
+    archivedRecords: projected.filter((record) => record.persistenceLevel === "archived"),
+    consolidationRequests: requests,
+    errors,
+    validCommands,
+    invalidCommands
   };
 }
-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: [] };
+function validateRetentionCommand(value, index) {
   if (!isPlainRecord(value)) {
-    return { ok: false, errors: ["record metadata must be an object when present"] };
+    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 = [];
-  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 (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 (!isNonEmptyString(value.recordId)) {
-    errors.push("record.recordId must be a non-empty string");
+  if (value.reason !== void 0 && typeof value.reason !== "string") {
+    errors.push("command.reason must be a string when present");
   }
-  if (!isAgenticMemoryKind(value.kind)) {
-    errors.push("record.kind is invalid");
+  if (kind === "archive") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+  } else if (kind === "restore") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+    if (value.persistenceLevel !== void 0 && (!isAgenticMemoryPersistenceLevel(value.persistenceLevel) || value.persistenceLevel === "archived")) {
+      errors.push("restore.persistenceLevel must be a non-archived persistence level when present");
+    }
+  } else if (kind === "setPersistenceLevel") {
+    if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+    if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+      errors.push("setPersistenceLevel.persistenceLevel is invalid");
+    }
+  } else if (kind === "requestConsolidation") {
+    if (!isDenseArrayOf(value.recordIds, isNonEmptyString) || value.recordIds.length === 0) {
+      errors.push("requestConsolidation.recordIds must be a non-empty string array");
+    }
+    if (value.requestId !== void 0 && (typeof value.requestId !== "string" || value.requestId.length === 0)) {
+      errors.push("requestConsolidation.requestId must be non-empty when present");
+    }
   }
-  if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
-    errors.push("record.persistenceLevel is invalid");
+  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)
+        }
+      ]
+    };
   }
-  if (!isAgenticMemoryArtifactKind(value.artifactKind)) {
-    errors.push("record.artifactKind is invalid");
+  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: []
+    };
   }
-  const scopeValidation = validateScope(value.scope);
-  if (!scopeValidation.ok) {
-    errors.push(...scopeValidation.errors.map((error) => `record.${error}`));
+  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: []
+    };
   }
-  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 }
-    })
+    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 contextState(projection, retrieval) {
-  if (projection === "error" || retrieval === "error") return "error";
-  if (projection === "partial" || retrieval === "partial") return "partial";
-  return retrieval;
+function retentionMissingRecords(command, records) {
+  if ("recordId" in command) return records.has(command.recordId) ? [] : [command.recordId];
+  return command.recordIds.filter((recordId) => !records.has(recordId));
 }
-function agenticStatusState(errorCount, validRecords) {
-  if (errorCount > 0 && validRecords === 0) return "error";
-  if (errorCount > 0) return "partial";
-  return validRecords > 0 ? "ready" : "empty";
+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 isAgenticMemoryKind(value) {
-  return value === "working" || value === "episodic" || value === "semantic" || value === "procedural" || value === "profile";
+function nonArchivedLevel(record) {
+  return record.persistenceLevel === "archived" ? "session" : record.persistenceLevel;
 }
-function isAgenticMemoryPersistenceLevel(value) {
-  return value === "turn" || value === "session" || value === "project" || value === "longTerm" || value === "permanent" || value === "archived";
+function withPersistenceLevel(record, persistenceLevel) {
+  return Object.freeze({
+    ...record,
+    persistenceLevel
+  });
 }
-function isAgenticMemoryArtifactKind(value) {
-  return value === "raw" || value === "insight" || value === "profile" || value === "procedure";
+function retentionErrorFromRecordError(error) {
+  return {
+    ...error,
+    code: error.code
+  };
+}
+
+// src/solutions/capability-admission.ts
+function capabilityAdmissionProposal(opts) {
+  return { kind: "capability-admission-proposal", ...opts };
+}
+function capabilityAdmissionProjector(graph, opts) {
+  const name = opts.name ?? "capabilityAdmissions";
+  const policyDeps = opts.admissionPolicies ?? [];
+  const now = opts.now ?? Date.now;
+  const runtime = graph.node(
+    [opts.proposals, opts.decisions, ...policyDeps],
+    (ctx) => {
+      const state = ctx.state.get() ?? emptyCapabilityAdmissionState();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const proposal = raw;
+        const issue = capabilityAdmissionProposalIssue(proposal);
+        if (issue !== void 0) {
+          emitIssue(
+            ctx,
+            state,
+            nextMalformedIssueKey(state, "proposal", proposalKeyFallback(proposal)),
+            issue
+          );
+          continue;
+        }
+        if (state.proposals.has(proposal.proposalId)) {
+          emitIssue(
+            ctx,
+            state,
+            `duplicate-proposal:${proposal.proposalId}`,
+            dataIssue(
+              "duplicate-capability-admission-proposal",
+              `CapabilityAdmissionProposal '${proposal.proposalId}' was already seen`,
+              { subjectId: proposal.subjectId, refs: capabilityProposalRefs(proposal) }
+            )
+          );
+          continue;
+        }
+        state.proposals.set(proposal.proposalId, proposal);
+      }
+      forEachPolicyDepBatch(ctx, 2, policyDeps.length, (raw) => {
+        const policy = raw;
+        const issue = capabilityAdmissionPolicyIssue(policy);
+        if (issue !== void 0) {
+          emitIssue(
+            ctx,
+            state,
+            nextMalformedIssueKey(state, "policy", policyKeyFallback(policy)),
+            issue
+          );
+          return;
+        }
+        if (state.policies.has(policy.policyId)) {
+          emitIssue(
+            ctx,
+            state,
+            `duplicate-policy:${policy.policyId}`,
+            dataIssue(
+              "duplicate-capability-admission-policy",
+              `CapabilityAdmissionPolicy '${policy.policyId}' was already seen`,
+              { refs: [ref("capability-admission-policy", policy.policyId)] }
+            )
+          );
+          return;
+        }
+        state.policies.set(policy.policyId, policy);
+      });
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const decision = raw;
+        const issue = capabilityAdmissionDecisionIssue(decision);
+        if (issue !== void 0) {
+          emitIssue(
+            ctx,
+            state,
+            nextMalformedIssueKey(state, "decision", decisionKeyFallback(decision)),
+            issue
+          );
+          continue;
+        }
+        if (state.decisions.has(decision.decisionId)) {
+          emitIssue(
+            ctx,
+            state,
+            `duplicate-decision:${decision.decisionId}`,
+            dataIssue(
+              "duplicate-capability-admission-decision",
+              `CapabilityAdmissionDecision '${decision.decisionId}' was already seen`,
+              { refs: capabilityDecisionRefs(decision) }
+            )
+          );
+          continue;
+        }
+        state.decisions.set(decision.decisionId, decision);
+      }
+      evaluateCapabilityAdmissions(ctx, state, now());
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "capabilityAdmissionProjector", partial: true }
+  );
+  return {
+    admissions: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/admissions`,
+      "capabilityAdmissions",
+      (fact) => fact.kind === "admission" ? fact.admission : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "capabilityAdmissionStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "capabilityAdmissionIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "capabilityAdmissionAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: capabilityAdmissionViews(graph, runtime, `${name}/views`)
+  };
 }
-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"] };
+function evaluateCapabilityAdmissions(ctx, state, admittedAtMs) {
+  for (const decision of state.decisions.values()) {
+    if (state.terminalDecisionIds.has(decision.decisionId)) continue;
+    evaluateCapabilityAdmission(ctx, state, decision, admittedAtMs);
+  }
+}
+function evaluateCapabilityAdmission(ctx, state, decision, admittedAtMs) {
+  const proposal = state.proposals.get(decision.proposalId);
+  if (proposal === void 0) {
+    emitIssue(
+      ctx,
+      state,
+      `missing-proposal:${decision.decisionId}:${decision.proposalId}`,
+      dataIssue(
+        "missing-capability-admission-proposal",
+        `CapabilityAdmissionDecision '${decision.decisionId}' references missing proposal '${decision.proposalId}'`,
+        { subjectId: decision.proposalId, refs: capabilityDecisionRefs(decision) }
+      )
+    );
+    return;
   }
-  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 policy = capabilityPolicyForDecision(state, decision);
+  if (typeof policy === "string") {
+    emitIssue(
+      ctx,
+      state,
+      `${policy}:${decision.decisionId}:${decision.policyId ?? "missing"}`,
+      dataIssue(policy, capabilityPolicyIssueMessage(policy, decision), {
+        subjectId: proposal.subjectId,
+        refs: capabilityDecisionRefs(decision, proposal)
+      })
+    );
+    if (policy === "stale-capability-admission-policy-ref")
+      state.terminalDecisionIds.add(decision.decisionId);
+    return;
   }
-  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 (policy !== void 0) {
+    const policyIssue = validateCapabilityAdmissionPolicy(policy, decision, proposal);
+    if (policyIssue !== void 0) {
+      emitIssue(
+        ctx,
+        state,
+        `${policyIssue.code}:${decision.decisionId}:${policy.policyId}`,
+        dataIssue(policyIssue.code, policyIssue.message, {
+          subjectId: proposal.subjectId,
+          refs: capabilityDecisionRefs(decision, proposal, policy)
+        })
+      );
+      return;
     }
   }
-  if (errors.length > 0) return { ok: false, errors };
-  return {
-    ok: true,
-    errors,
-    scope: Object.freeze({
-      ...scope.sessionId === void 0 ? {} : { sessionId: scope.sessionId },
-      ...scope.projectId === void 0 ? {} : { projectId: scope.projectId },
-      ...scope.userId === void 0 ? {} : { userId: scope.userId },
-      ...scope.tenantId === void 0 ? {} : { tenantId: scope.tenantId }
-    })
-  };
-}
-function isPlainRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function ownKeys(value) {
-  return Object.keys(value).sort();
-}
-function assertExactKeys(value, expected, label) {
-  const actual = ownKeys(value);
-  const want = [...expected].sort();
-  if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
-    throw new TypeError(`${label}: unexpected fields ${actual.join(",")}`);
+  if (state.admissionsById.has(decision.admissionId)) {
+    emitIssue(
+      ctx,
+      state,
+      `duplicate-admission-id:${decision.admissionId}`,
+      dataIssue(
+        "duplicate-capability-admission",
+        `CapabilityAdmission '${decision.admissionId}' was already emitted`,
+        { subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) }
+      )
+    );
+    state.terminalDecisionIds.add(decision.decisionId);
+    return;
   }
-}
-function assertAgenticMemoryRecordCodecShape(value) {
-  if (!isPlainRecord(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+  if (state.admissionsByProposal.has(decision.proposalId)) {
+    emitIssue(
+      ctx,
+      state,
+      `duplicate-admission-proposal:${decision.proposalId}:${decision.decisionId}`,
+      dataIssue(
+        "duplicate-capability-admission-proposal",
+        `CapabilityAdmissionProposal '${decision.proposalId}' already has an admission decision`,
+        { subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) }
+      )
+    );
+    state.terminalDecisionIds.add(decision.decisionId);
+    return;
   }
-  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");
+  const admissionState = admissionStateForOutcome(decision.outcome);
+  if (admissionState === void 0) {
+    emitIssue(
+      ctx,
+      state,
+      `unsupported-outcome:${decision.decisionId}:${String(decision.outcome)}`,
+      dataIssue(
+        "unsupported-capability-admission-outcome",
+        `CapabilityAdmissionDecision '${decision.decisionId}' uses unsupported outcome '${String(decision.outcome)}'`,
+        { subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) }
+      )
+    );
+    state.terminalDecisionIds.add(decision.decisionId);
+    return;
   }
-  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"
+  const admission = {
+    kind: "capability-admission",
+    admissionId: decision.admissionId,
+    proposalId: proposal.proposalId,
+    subjectId: proposal.subjectId,
+    capability: cloneCapabilityRef(proposal.capability),
+    state: admissionState,
+    decisionId: decision.decisionId,
+    boundaryName: proposal.boundaryName,
+    role: proposal.role,
+    policyId: decision.policyId,
+    reason: decision.reason ?? proposal.reason,
+    sourceRefs: capabilityDecisionRefs(decision, proposal, policy),
+    admittedAtMs: decision.decidedAtMs ?? admittedAtMs,
+    metadata: {
+      ...proposal.metadata ?? {},
+      ...policy?.metadata ?? {},
+      ...decision.metadata ?? {}
+    }
+  };
+  state.admissionsById.set(admission.admissionId, admission);
+  state.admissionsByProposal.set(admission.proposalId, admission);
+  state.terminalDecisionIds.add(decision.decisionId);
+  emitAdmission(ctx, state, admission);
+}
+function capabilityAdmissionViews(graph, runtime, name) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        admissionsByProposal: /* @__PURE__ */ new Map(),
+        admissionsBySubject: /* @__PURE__ */ new Map(),
+        issues: [],
+        audit: []
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const fact = raw;
+        if (fact.kind === "admission") {
+          const admission = fact.admission;
+          state.admissionsByProposal.set(admission.proposalId, admission);
+          const bySubject = state.admissionsBySubject.get(admission.subjectId) ?? [];
+          bySubject.push(admission);
+          state.admissionsBySubject.set(admission.subjectId, bySubject);
+        }
+        if (fact.kind === "issue") state.issues.push(fact.issue);
+        if (fact.kind === "audit") state.audit.push(fact.audit);
+      }
+      ctx.state.set(state);
+      ctx.down([["DATA", freezeCapabilityAdmissionViews(state)]]);
+    },
+    { name, factory: "capabilityAdmissionViews" }
   );
-  assertStrictJsonValue(fragment.tags, "record.fragment.tags");
-  assertStrictJsonValue(fragment.sources, "record.fragment.sources");
-  if (fragment.embedding !== void 0) {
-    assertStrictJsonValue(fragment.embedding, "record.fragment.embedding");
-  }
-  if (value.scope !== void 0) assertScopeFrame(value.scope);
 }
-function assertNoSymbolKeys(value, label) {
-  if (Object.getOwnPropertySymbols(value).length > 0) {
-    throw new TypeError(`${label}: unexpected symbol fields`);
+function emitAdmission(ctx, state, admission) {
+  state.statusSeq += 1;
+  state.auditSeq += 1;
+  const statusState = capabilityAdmissionStatusState(admission.state);
+  const status = {
+    kind: "capability-admission-status",
+    statusId: `${admission.subjectId}:${statusState}:${state.statusSeq}`,
+    state: statusState,
+    proposalId: admission.proposalId,
+    admissionId: admission.admissionId,
+    subjectId: admission.subjectId,
+    capabilityId: admission.capability.id,
+    capabilityKind: admission.capability.kind,
+    policyId: admission.policyId,
+    sourceRefs: admission.sourceRefs
+  };
+  const audit = {
+    id: `${admission.subjectId}:${statusState}:${state.auditSeq}`,
+    kind: `capability-admission-${admission.state}`,
+    subjectId: admission.subjectId,
+    sourceRefs: admission.sourceRefs,
+    metadata: {
+      admissionId: admission.admissionId,
+      capabilityId: admission.capability.id,
+      capabilityKind: admission.capability.kind,
+      policyId: admission.policyId,
+      proposalId: admission.proposalId
+    }
+  };
+  ctx.down([
+    ["DATA", { kind: "admission", admission }],
+    ["DATA", { kind: "status", status }],
+    ["DATA", { kind: "audit", audit }]
+  ]);
+}
+function emitIssue(ctx, state, key, issue) {
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  state.statusSeq += 1;
+  state.auditSeq += 1;
+  const status = {
+    kind: "capability-admission-status",
+    statusId: `capability-admission-issue:${state.statusSeq}`,
+    state: "capability-admission-issue",
+    subjectId: issue.subjectId,
+    issues: [issue]
+  };
+  const audit = {
+    id: `capability-admission-issue:${state.auditSeq}`,
+    kind: "capability-admission-issue",
+    subjectId: issue.subjectId,
+    message: issue.message,
+    issueCode: issue.code
+  };
+  ctx.down([
+    ["DATA", { kind: "issue", issue }],
+    ["DATA", { kind: "status", status }],
+    ["DATA", { kind: "audit", audit }]
+  ]);
+}
+function capabilityAdmissionProposalIssue(proposal) {
+  if (proposal.kind !== "capability-admission-proposal" || typeof proposal.proposalId !== "string" || proposal.proposalId.length === 0 || typeof proposal.subjectId !== "string" || proposal.subjectId.length === 0 || !isBoundaryCapabilityRef(proposal.capability)) {
+    return dataIssue(
+      "malformed-capability-admission-proposal",
+      "CapabilityAdmissionProposal requires proposalId, subjectId, and a D348 BoundaryCapabilityRef",
+      { subjectId: typeof proposal.subjectId === "string" ? proposal.subjectId : void 0 }
+    );
   }
+  return void 0;
 }
-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 capabilityAdmissionPolicyIssue(policy) {
+  if (policy.kind !== "capability-admission-policy" || typeof policy.policyId !== "string" || policy.policyId.length === 0 || policy.capabilityIds !== void 0 && (!Array.isArray(policy.capabilityIds) || !policy.capabilityIds.every((id) => typeof id === "string" && id.length > 0)) || policy.capabilityKinds !== void 0 && (!Array.isArray(policy.capabilityKinds) || !policy.capabilityKinds.every(isBoundaryCapabilityKind)) || policy.requiredOnly !== void 0 && typeof policy.requiredOnly !== "boolean" || policy.allowedOutcomes !== void 0 && (!Array.isArray(policy.allowedOutcomes) || !policy.allowedOutcomes.every(isCapabilityAdmissionOutcome))) {
+    return dataIssue(
+      "malformed-capability-admission-policy",
+      "CapabilityAdmissionPolicy requires a policyId and D348 capability/outcome filters",
+      { subjectId: typeof policy.policyId === "string" ? policy.policyId : void 0 }
+    );
   }
-  return out;
+  return void 0;
 }
-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`);
+function capabilityAdmissionDecisionIssue(decision) {
+  if (decision.kind !== "capability-admission-decision" || typeof decision.decisionId !== "string" || decision.decisionId.length === 0 || typeof decision.admissionId !== "string" || decision.admissionId.length === 0 || typeof decision.proposalId !== "string" || decision.proposalId.length === 0 || !isCapabilityAdmissionOutcome(decision.outcome) || decision.policyId !== void 0 && (typeof decision.policyId !== "string" || decision.policyId.length === 0)) {
+    return dataIssue(
+      "malformed-capability-admission-decision",
+      "CapabilityAdmissionDecision requires decisionId, admissionId, proposalId, and allow/block/defer outcome",
+      { subjectId: typeof decision.proposalId === "string" ? decision.proposalId : void 0 }
+    );
   }
-  return BigInt(value);
+  return void 0;
 }
-function assertStrictJsonValue(value, label) {
-  try {
-    strictJsonCodec.encode(value);
-    return value;
-  } catch (error) {
-    throw new TypeError(`${label} must be strict JSON: ${errorMessage(error)}`);
+function validateCapabilityAdmissionPolicy(policy, decision, proposal) {
+  if (policy.capabilityIds !== void 0 && !policy.capabilityIds.includes(proposal.capability.id)) {
+    return {
+      code: "capability-admission-policy-mismatch",
+      message: `CapabilityAdmissionPolicy '${policy.policyId}' does not apply to capability '${proposal.capability.id}'`
+    };
   }
-}
-function assertScopeFrame(value) {
-  if (!isPlainRecord(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: scope must be an object when present");
+  if (policy.capabilityKinds !== void 0 && !policy.capabilityKinds.includes(proposal.capability.kind)) {
+    return {
+      code: "capability-admission-policy-mismatch",
+      message: `CapabilityAdmissionPolicy '${policy.policyId}' does not apply to capability kind '${proposal.capability.kind}'`
+    };
   }
-  assertStrictJsonValue(value, "record.scope");
-  const validation = validateScope(value);
-  if (!validation.ok || validation.scope === void 0) {
-    throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
+  if (policy.requiredOnly === true && !proposal.capability.required) {
+    return {
+      code: "capability-admission-policy-mismatch",
+      message: `CapabilityAdmissionPolicy '${policy.policyId}' applies only to required capabilities`
+    };
   }
-  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"
+  if (policy.allowedOutcomes !== void 0 && !policy.allowedOutcomes.includes(decision.outcome)) {
+    return {
+      code: "unsupported-capability-admission-outcome",
+      message: `CapabilityAdmissionPolicy '${policy.policyId}' does not allow outcome '${decision.outcome}'`
+    };
+  }
+  return void 0;
+}
+function capabilityPolicyForDecision(state, decision) {
+  if (decision.policyId === void 0) return void 0;
+  const stalePolicyRef = (decision.sourceRefs ?? []).find(
+    (sourceRef) => sourceRef.kind === "capability-admission-policy" && sourceRef.id !== decision.policyId
   );
-  return validation.scope;
+  if (stalePolicyRef !== void 0) return "stale-capability-admission-policy-ref";
+  return state.policies.get(decision.policyId) ?? "missing-capability-admission-policy";
 }
-function assertKindValue(value) {
-  if (!isAgenticMemoryKind(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid memory kind");
+function capabilityPolicyIssueMessage(code, decision) {
+  if (code === "missing-capability-admission-policy") {
+    return `CapabilityAdmissionPolicy '${decision.policyId}' was referenced but not present`;
   }
-  return value;
+  return `CapabilityAdmissionDecision '${decision.decisionId}' carries a stale admission policy source ref`;
 }
-function assertPersistenceLevelValue(value) {
-  if (!isAgenticMemoryPersistenceLevel(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
-  }
-  return value;
+function admissionStateForOutcome(outcome) {
+  if (outcome === "allow") return "allowed";
+  if (outcome === "block") return "blocked";
+  if (outcome === "defer") return "deferred";
+  return void 0;
 }
-function assertArtifactKindValue(value) {
-  if (!isAgenticMemoryArtifactKind(value)) {
-    throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
-  }
-  return value;
+function capabilityAdmissionStatusState(state) {
+  if (state === "allowed") return "capability-admission-allowed";
+  if (state === "blocked") return "capability-admission-blocked";
+  return "capability-admission-deferred";
 }
-function assertNonEmptyString(value, label) {
-  if (!isNonEmptyString(value)) throw new TypeError(`${label} must be a non-empty string`);
-  return value;
+function cloneCapabilityRef(ref2) {
+  return {
+    id: ref2.id,
+    kind: ref2.kind,
+    required: ref2.required,
+    ...ref2.sourceRefs === void 0 ? {} : { sourceRefs: [...ref2.sourceRefs] }
+  };
 }
-function assertString(value, label) {
-  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
-  return value;
+function isBoundaryCapabilityRef(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.id === "string" && record.id.length > 0 && isBoundaryCapabilityKind(record.kind) && typeof record.required === "boolean" && (record.sourceRefs === void 0 || Array.isArray(record.sourceRefs) && record.sourceRefs.every((sourceRef) => typeof sourceRef === "string"));
 }
-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 isBoundaryCapabilityKind(value) {
+  return value === "auth" || value === "permission" || value === "config" || value === "resource";
 }
-function assertStringArray(value, label) {
-  if (!isDenseArrayOf(value, (item) => typeof item === "string")) {
-    throw new TypeError(`${label} must be a readonly string array`);
-  }
-  return Object.freeze([...value]);
+function isCapabilityAdmissionOutcome(value) {
+  return value === "allow" || value === "block" || value === "defer";
 }
-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 proposalKeyFallback(proposal) {
+  return typeof proposal.proposalId === "string" && proposal.proposalId.length > 0 ? proposal.proposalId : `${stringValue(proposal.subjectId) ?? "unknown"}:${capabilityKeyFallback(proposal.capability)}`;
 }
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
+function policyKeyFallback(policy) {
+  return typeof policy.policyId === "string" && policy.policyId.length > 0 ? policy.policyId : "unknown";
 }
-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 decisionKeyFallback(decision) {
+  return typeof decision.decisionId === "string" && decision.decisionId.length > 0 ? decision.decisionId : `${stringValue(decision.proposalId) ?? "unknown"}:${stringValue(decision.admissionId) ?? "unknown"}`;
+}
+function capabilityKeyFallback(value) {
+  if (!isBoundaryCapabilityRef(value)) return "unknown-capability";
+  return `${value.kind}:${value.id}`;
+}
+function nextMalformedIssueKey(state, kind, fallback) {
+  state.issueSeq += 1;
+  return `malformed-${kind}:${state.issueSeq}:${fallback}`;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function capabilityProposalRefs(proposal) {
+  return uniqueSourceRefs([
+    ref("capability-admission-proposal", proposal.proposalId),
+    ref("boundary-capability", `${proposal.capability.kind}:${proposal.capability.id}`),
+    ...proposal.sourceRefs ?? []
+  ]);
+}
+function capabilityDecisionRefs(decision, proposal, policy) {
+  return uniqueSourceRefs([
+    ref("capability-admission-decision", decision.decisionId),
+    ref("capability-admission", decision.admissionId),
+    ref("capability-admission-proposal", decision.proposalId),
+    ...proposal === void 0 ? [] : capabilityProposalRefs(proposal),
+    ...decision.policyId === void 0 ? [] : [ref("capability-admission-policy", decision.policyId)],
+    ...policy === void 0 ? [] : [ref("capability-admission-policy", policy.policyId)],
+    ...decision.sourceRefs ?? []
+  ]);
+}
+function forEachPolicyDepBatch(ctx, start, count, fn) {
+  for (let i = 0; i < count; i += 1) {
+    for (const value of depBatch(ctx, start + i) ?? []) fn(value);
   }
-  return true;
 }
-function freezeError(error) {
-  return Object.freeze({
-    ...error,
-    ...error.validationErrors === void 0 ? {} : { validationErrors: Object.freeze([...error.validationErrors]) }
-  });
+function projectRuntimeFact(graph, runtime, name, factory, pick) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        const value = pick(typed);
+        if (value !== void 0) ctx.down([["DATA", value]]);
+      }
+    },
+    { name, factory }
+  );
 }
-function safeArrayLength(value) {
-  try {
-    return value.length;
-  } catch {
-    return void 0;
+function freezeCapabilityAdmissionViews(state) {
+  return {
+    admissionsByProposal: new Map(state.admissionsByProposal),
+    admissionsBySubject: new Map(
+      Array.from(state.admissionsBySubject, ([key, value]) => [key, Object.freeze([...value])])
+    ),
+    issues: Object.freeze([...state.issues]),
+    audit: Object.freeze([...state.audit])
+  };
+}
+function emptyCapabilityAdmissionState() {
+  return {
+    proposals: /* @__PURE__ */ new Map(),
+    policies: /* @__PURE__ */ new Map(),
+    decisions: /* @__PURE__ */ new Map(),
+    admissionsById: /* @__PURE__ */ new Map(),
+    admissionsByProposal: /* @__PURE__ */ new Map(),
+    terminalDecisionIds: /* @__PURE__ */ new Set(),
+    issueKeys: /* @__PURE__ */ new Set(),
+    issueSeq: 0,
+    statusSeq: 0,
+    auditSeq: 0
+  };
+}
+function dataIssue(code, message, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: "error",
+    subjectId: opts.subjectId,
+    refs: opts.refs?.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+    details: opts.details
+  };
+}
+function uniqueSourceRefs(sourceRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const sourceRef of sourceRefs) {
+    const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(sourceRef);
   }
+  return out;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function ref(kind, id) {
+  return { 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-COHO25CZ.js.map
+//# sourceMappingURL=chunk-4NWSNI4K.js.map