@graphrefly/ts 0.0.0 → 0.0.1

package/dist/agentic-memory-DfuVZ-lY.d.cts

@@ -0,0 +1,517 @@
+import { d as Graph } from './graph-DCEWh4T2.cjs';
+import { b as StrictJsonValue$1, C as Codec } from './codec-BB7p8fJc.cjs';
+import { N as Node } from './types-CcPIn7sy.cjs';
+import { F as FactId, x as MemoryFragment, N as MemoryRetrievalQuery, B as MemoryRetrievalBundle, O as MemoryRetrievalSnapshot, L as MemoryRetrievalIndex, M as MemoryAnswer, G as MemoryRetrievalCursor, H as MemoryRetrievalError, P as MemoryRetrievalStatus, c as KnowledgeAssertionSubject, a as KnowledgeAssertionObject, K as KnowledgeAssertion } from './semantic-memory-graph-DKuNzuWw.cjs';
+
+/**
+ * Thin agentic-memory solution surface.
+ *
+ * D125 places vertical application kits under solutions, while D158 keeps
+ * semantic-memory retrieval/ranking in horizontal patterns. This v0 bundle
+ * composes those lower layers into graph-visible facts only: no agent runtime,
+ * hidden scheduler, storage restore/hydration, LLM loop, or protocol behavior.
+ */
+
+type AgenticMemoryStrictJsonValue = StrictJsonValue$1;
+type StrictJsonValue = StrictJsonValue$1;
+
+/** Agent-facing memory category. D164 keeps this separate from durability and artifact kind. */
+type AgenticMemoryKind = "working" | "episodic" | "semantic" | "procedural" | "profile";
+/** Semantic durability/retention policy metadata. This is not a storage tier handle. */
+type AgenticMemoryPersistenceLevel = "turn" | "session" | "project" | "longTerm" | "permanent" | "archived";
+/** Whether the record is raw evidence or a derived artifact. */
+type AgenticMemoryArtifactKind = "raw" | "insight" | "profile" | "procedure";
+/** Optional solution-facing scope metadata. Scope ids are ordinary DATA facts. */
+interface AgenticMemoryScope {
+    readonly sessionId?: string;
+    readonly projectId?: string;
+    readonly userId?: string;
+    readonly tenantId?: string;
+}
+/**
+ * D164 solution envelope over a lower-layer MemoryFragment.
+ *
+ * The envelope carries agentic-memory metadata only. It intentionally owns no
+ * storage tiers/keys/adapters, restore/hydration behavior, timers, schedulers,
+ * LLM/tool/runner handles, or protocol semantics.
+ */
+interface AgenticMemoryRecord<T = unknown> {
+    readonly id: FactId;
+    readonly kind: AgenticMemoryKind;
+    readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+    readonly artifactKind: AgenticMemoryArtifactKind;
+    readonly scope?: AgenticMemoryScope;
+    readonly fragment: MemoryFragment<T>;
+}
+interface AgenticMemoryRecordMetadata {
+    readonly recordId: FactId;
+    readonly kind: AgenticMemoryKind;
+    readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+    readonly artifactKind: AgenticMemoryArtifactKind;
+    readonly scope?: AgenticMemoryScope;
+}
+interface AgenticMemoryProjectionCursor {
+    readonly evaluation: number;
+    readonly validRecords: number;
+    readonly invalidRecords: number;
+    readonly projectedFragments: number;
+}
+type AgenticMemoryStatusState = "ready" | "empty" | "partial" | "error";
+interface AgenticMemoryStatus {
+    readonly state: AgenticMemoryStatusState;
+    readonly cursor: AgenticMemoryProjectionCursor;
+}
+type AgenticMemoryErrorCode = "duplicate-record-id" | "duplicate-fragment-id" | "invalid-records-input" | "invalid-record" | "invalid-record-kind" | "invalid-persistence-level" | "invalid-artifact-kind" | "invalid-scope" | "invalid-fragment";
+interface AgenticMemoryError {
+    readonly code: AgenticMemoryErrorCode;
+    readonly message: string;
+    readonly index?: number;
+    readonly recordId?: FactId;
+    readonly fragmentId?: FactId;
+    readonly record?: unknown;
+    readonly validationErrors?: readonly string[];
+    readonly cursor: AgenticMemoryProjectionCursor;
+}
+interface AgenticMemoryProjectionSnapshot<T = unknown> {
+    readonly records: readonly AgenticMemoryRecord<T>[];
+    readonly fragments: readonly MemoryFragment<T>[];
+    readonly metadataByFragmentId: Readonly<Record<FactId, AgenticMemoryRecordMetadata>>;
+    readonly status: AgenticMemoryStatus;
+    readonly errors: readonly AgenticMemoryError[];
+    readonly cursor: AgenticMemoryProjectionCursor;
+}
+/** Source/provenance projection for a valid memory fragment. */
+interface AgenticMemorySourceProjection {
+    readonly fragmentId: FactId;
+    readonly record?: AgenticMemoryRecordMetadata;
+    readonly sources: readonly FactId[];
+    readonly parentFragmentId?: FactId;
+    readonly provenance?: string;
+}
+/** A context-ready item derived from ranked memory retrieval results. */
+interface AgenticMemoryContextEntry<T = unknown> {
+    readonly fragmentId: FactId;
+    readonly payload: T;
+    readonly confidence: number;
+    readonly tags: readonly string[];
+    readonly sources: readonly FactId[];
+    readonly record?: AgenticMemoryRecordMetadata;
+    readonly fragment: MemoryFragment<T>;
+}
+type AgenticMemoryContextState = "ready" | "empty" | "partial" | "error";
+/**
+ * Context-ready ranked memory output for callers such as prompt builders.
+ *
+ * This is still only a DATA fact. It does not extract, summarize, reflect, run
+ * tools, or choose an autonomous action.
+ */
+interface AgenticMemoryContext<T = unknown> {
+    readonly state: AgenticMemoryContextState;
+    readonly query: MemoryRetrievalQuery;
+    readonly entries: readonly AgenticMemoryContextEntry<T>[];
+    readonly cursor: MemoryRetrievalCursor;
+    readonly errors: readonly AgenticMemoryError[];
+    readonly retrievalErrors: readonly MemoryRetrievalError[];
+    readonly contextReady: boolean;
+}
+/** Explicit KG assertion draft fact; extraction/LLM work happens outside this bundle. */
+interface AgenticMemoryKgAssertionDraft {
+    readonly id: FactId;
+    readonly recordId: FactId;
+    readonly fragmentId: FactId;
+    readonly subject: KnowledgeAssertionSubject;
+    readonly predicate: string;
+    readonly object: KnowledgeAssertionObject;
+    readonly confidence?: number;
+    readonly sources?: readonly FactId[];
+    readonly provenance?: string;
+}
+interface AgenticMemoryKgProjectionCursor {
+    readonly evaluation: number;
+    readonly validRecords: number;
+    readonly validDrafts: number;
+    readonly invalidDrafts: number;
+    readonly projectedAssertions: number;
+}
+type AgenticMemoryKgProjectionStatusState = AgenticMemoryStatusState;
+interface AgenticMemoryKgProjectionStatus {
+    readonly state: AgenticMemoryKgProjectionStatusState;
+    readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+type AgenticMemoryKgProjectionErrorCode = AgenticMemoryErrorCode | "invalid-drafts-input" | "invalid-draft" | "duplicate-assertion-id" | "missing-record-ref" | "missing-fragment-ref" | "fragment-record-mismatch" | "invalid-assertion-shape";
+interface AgenticMemoryKgProjectionError {
+    readonly code: AgenticMemoryKgProjectionErrorCode;
+    readonly message: string;
+    readonly index?: number;
+    readonly assertionId?: FactId;
+    readonly recordId?: FactId;
+    readonly fragmentId?: FactId;
+    readonly draft?: unknown;
+    readonly record?: unknown;
+    readonly validationErrors?: readonly string[];
+    readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+interface AgenticMemoryKgProjectionSnapshot {
+    readonly assertions: readonly KnowledgeAssertion[];
+    readonly status: AgenticMemoryKgProjectionStatus;
+    readonly errors: readonly AgenticMemoryKgProjectionError[];
+    readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+interface AgenticMemoryKgProjectionBundle {
+    readonly input: {
+        readonly records: Node<readonly AgenticMemoryRecord[]>;
+        readonly drafts: Node<readonly AgenticMemoryKgAssertionDraft[]>;
+    };
+    readonly projection: Node<AgenticMemoryKgProjectionSnapshot>;
+    readonly assertions: Node<readonly KnowledgeAssertion[]>;
+    readonly status: Node<AgenticMemoryKgProjectionStatus>;
+    readonly errors: Node<readonly AgenticMemoryKgProjectionError[]>;
+    readonly cursor: Node<AgenticMemoryKgProjectionCursor>;
+}
+interface AgenticMemoryKgProjectionBundleOptions {
+    readonly name?: string;
+    readonly records: Node<readonly AgenticMemoryRecord[]>;
+    readonly drafts: Node<readonly AgenticMemoryKgAssertionDraft[]>;
+}
+declare const AGENTIC_MEMORY_RECORD_FRAME_FORMAT = "graphrefly.agenticMemoryRecord";
+declare const AGENTIC_MEMORY_RECORD_FRAME_VERSION = 1;
+interface AgenticMemoryFragmentFrame<TJson extends StrictJsonValue = StrictJsonValue> {
+    readonly id: FactId;
+    readonly payload: TJson;
+    readonly tNs: string;
+    readonly validFrom?: string;
+    readonly validTo?: string;
+    readonly confidence: number;
+    readonly tags: readonly string[];
+    readonly sources: readonly FactId[];
+    readonly embedding?: readonly number[];
+    readonly parentFragmentId?: FactId;
+    readonly provenance?: string;
+}
+interface AgenticMemoryRecordFrame<TJson extends StrictJsonValue = StrictJsonValue> {
+    readonly format: typeof AGENTIC_MEMORY_RECORD_FRAME_FORMAT;
+    readonly version: typeof AGENTIC_MEMORY_RECORD_FRAME_VERSION;
+    readonly record: {
+        readonly id: FactId;
+        readonly kind: AgenticMemoryKind;
+        readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+        readonly artifactKind: AgenticMemoryArtifactKind;
+        readonly scope?: AgenticMemoryScope;
+        readonly fragment: AgenticMemoryFragmentFrame<TJson>;
+    };
+}
+type AgenticMemoryRetentionCommand = {
+    readonly id: FactId;
+    readonly kind: "archive";
+    readonly recordId: FactId;
+    readonly reason?: string;
+} | {
+    readonly id: FactId;
+    readonly kind: "restore";
+    readonly recordId: FactId;
+    readonly persistenceLevel?: Exclude<AgenticMemoryPersistenceLevel, "archived">;
+    readonly reason?: string;
+} | {
+    readonly id: FactId;
+    readonly kind: "setPersistenceLevel";
+    readonly recordId: FactId;
+    readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+    readonly reason?: string;
+} | {
+    readonly id: FactId;
+    readonly kind: "requestConsolidation";
+    readonly recordIds: readonly FactId[];
+    readonly requestId?: FactId;
+    readonly reason?: string;
+};
+interface AgenticMemoryConsolidationRequest {
+    readonly id: FactId;
+    readonly commandId: FactId;
+    readonly recordIds: readonly FactId[];
+    readonly reason?: string;
+}
+interface AgenticMemoryRetentionCursor {
+    readonly evaluation: number;
+    readonly validRecords: number;
+    readonly validCommands: number;
+    readonly invalidCommands: number;
+    readonly activeRecords: number;
+    readonly archivedRecords: number;
+    readonly consolidationRequests: number;
+}
+interface AgenticMemoryRetentionStatus {
+    readonly state: AgenticMemoryStatusState;
+    readonly cursor: AgenticMemoryRetentionCursor;
+}
+type AgenticMemoryRetentionErrorCode = AgenticMemoryErrorCode | "invalid-commands-input" | "invalid-command" | "duplicate-command-id" | "missing-record-ref";
+interface AgenticMemoryRetentionError {
+    readonly code: AgenticMemoryRetentionErrorCode;
+    readonly message: string;
+    readonly index?: number;
+    readonly commandId?: FactId;
+    readonly recordId?: FactId;
+    readonly recordIds?: readonly FactId[];
+    readonly command?: unknown;
+    readonly record?: unknown;
+    readonly validationErrors?: readonly string[];
+    readonly cursor: AgenticMemoryRetentionCursor;
+}
+interface AgenticMemoryRetentionSnapshot<T = unknown> {
+    readonly activeRecords: readonly AgenticMemoryRecord<T>[];
+    readonly archivedRecords: readonly AgenticMemoryRecord<T>[];
+    readonly consolidationRequests: readonly AgenticMemoryConsolidationRequest[];
+    readonly status: AgenticMemoryRetentionStatus;
+    readonly errors: readonly AgenticMemoryRetentionError[];
+    readonly cursor: AgenticMemoryRetentionCursor;
+}
+interface AgenticMemoryRetentionBundle<T = unknown> {
+    readonly input: {
+        readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+        readonly commands: Node<readonly AgenticMemoryRetentionCommand[]>;
+    };
+    readonly projection: Node<AgenticMemoryRetentionSnapshot<T>>;
+    readonly activeRecords: Node<readonly AgenticMemoryRecord<T>[]>;
+    readonly archivedRecords: Node<readonly AgenticMemoryRecord<T>[]>;
+    readonly consolidationRequests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+    readonly status: Node<AgenticMemoryRetentionStatus>;
+    readonly errors: Node<readonly AgenticMemoryRetentionError[]>;
+    readonly cursor: Node<AgenticMemoryRetentionCursor>;
+}
+interface AgenticMemoryRetentionBundleOptions<T = unknown> {
+    readonly name?: string;
+    readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+    readonly commands: Node<readonly AgenticMemoryRetentionCommand[]>;
+}
+type AgenticMemoryConsolidationOutcome<T = unknown> = {
+    readonly id: FactId;
+    readonly requestId: FactId;
+    readonly kind: "proposedRecords";
+    readonly records: readonly AgenticMemoryRecord<T>[];
+    readonly provenance?: string;
+} | {
+    readonly id: FactId;
+    readonly requestId: FactId;
+    readonly kind: "failed";
+    readonly message: string;
+    readonly provenance?: string;
+};
+interface AgenticMemoryConsolidationRecordDraft<T = unknown> {
+    readonly id: FactId;
+    readonly requestId: FactId;
+    readonly outcomeId: FactId;
+    readonly record: AgenticMemoryRecord<T>;
+}
+interface AgenticMemoryConsolidationCommand {
+    readonly id: FactId;
+    readonly kind: "proposeRecords" | "markFailed";
+    readonly requestId: FactId;
+    readonly outcomeId: FactId;
+    readonly draftIds?: readonly FactId[];
+    readonly message?: string;
+}
+interface AgenticMemoryConsolidationResult {
+    readonly id: FactId;
+    readonly requestId: FactId;
+    readonly outcomeId: FactId;
+    readonly state: "proposed" | "failed";
+    readonly sourceRecordIds: readonly FactId[];
+    readonly proposedRecordIds: readonly FactId[];
+    readonly message?: string;
+    readonly provenance?: string;
+}
+interface AgenticMemoryConsolidationCursor {
+    readonly evaluation: number;
+    readonly validRequests: number;
+    readonly validOutcomes: number;
+    readonly invalidOutcomes: number;
+    readonly results: number;
+    readonly proposedRecordDrafts: number;
+}
+interface AgenticMemoryConsolidationStatus {
+    readonly state: AgenticMemoryStatusState;
+    readonly cursor: AgenticMemoryConsolidationCursor;
+}
+type AgenticMemoryConsolidationErrorCode = AgenticMemoryRetentionErrorCode | "invalid-outcomes-input" | "invalid-outcome" | "duplicate-outcome-id" | "missing-request-ref" | "invalid-proposed-record";
+interface AgenticMemoryConsolidationError {
+    readonly code: AgenticMemoryConsolidationErrorCode;
+    readonly message: string;
+    readonly index?: number;
+    readonly outcomeId?: FactId;
+    readonly requestId?: FactId;
+    readonly recordId?: FactId;
+    readonly outcome?: unknown;
+    readonly validationErrors?: readonly string[];
+    readonly cursor: AgenticMemoryConsolidationCursor;
+}
+interface AgenticMemoryConsolidationSnapshot<T = unknown> {
+    readonly results: readonly AgenticMemoryConsolidationResult[];
+    readonly proposedRecordDrafts: readonly AgenticMemoryConsolidationRecordDraft<T>[];
+    readonly commands: readonly AgenticMemoryConsolidationCommand[];
+    readonly status: AgenticMemoryConsolidationStatus;
+    readonly errors: readonly AgenticMemoryConsolidationError[];
+    readonly cursor: AgenticMemoryConsolidationCursor;
+}
+interface AgenticMemoryConsolidationBundle<T = unknown> {
+    readonly input: {
+        readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+        readonly requests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+        readonly outcomes: Node<readonly AgenticMemoryConsolidationOutcome<T>[]>;
+    };
+    readonly projection: Node<AgenticMemoryConsolidationSnapshot<T>>;
+    readonly results: Node<readonly AgenticMemoryConsolidationResult[]>;
+    readonly proposedRecordDrafts: Node<readonly AgenticMemoryConsolidationRecordDraft<T>[]>;
+    readonly commands: Node<readonly AgenticMemoryConsolidationCommand[]>;
+    readonly status: Node<AgenticMemoryConsolidationStatus>;
+    readonly errors: Node<readonly AgenticMemoryConsolidationError[]>;
+    readonly cursor: Node<AgenticMemoryConsolidationCursor>;
+}
+interface AgenticMemoryConsolidationBundleOptions<T = unknown> {
+    readonly name?: string;
+    readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+    readonly requests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+    readonly outcomes: Node<readonly AgenticMemoryConsolidationOutcome<T>[]>;
+}
+interface AgenticMemoryContextText {
+    readonly fragmentId: FactId;
+    readonly text: string;
+    readonly cost?: number;
+    readonly metadata?: Readonly<Record<string, StrictJsonValue>>;
+}
+interface AgenticMemoryContextPackingPolicy {
+    readonly maxEntries?: number;
+    readonly maxChars?: number;
+    readonly maxCost?: number;
+    readonly includeMetadata?: boolean;
+}
+interface AgenticMemoryPackedContextEntry {
+    readonly fragmentId: FactId;
+    readonly text: string;
+    readonly cost: number;
+    readonly chars: number;
+    readonly record?: AgenticMemoryRecordMetadata;
+    readonly metadata?: Readonly<Record<string, StrictJsonValue>>;
+}
+interface AgenticMemoryPackedContext {
+    readonly entries: readonly AgenticMemoryPackedContextEntry[];
+    readonly text: string;
+    readonly totalChars: number;
+    readonly totalCost: number;
+    readonly truncated: boolean;
+}
+interface AgenticMemoryContextPackingCursor {
+    readonly evaluation: number;
+    readonly inputEntries: number;
+    readonly packedEntries: number;
+    readonly omittedEntries: number;
+    readonly totalChars: number;
+    readonly totalCost: number;
+}
+interface AgenticMemoryContextPackingStatus {
+    readonly state: AgenticMemoryStatusState;
+    readonly cursor: AgenticMemoryContextPackingCursor;
+}
+type AgenticMemoryContextPackingErrorCode = "invalid-context" | "invalid-texts-input" | "invalid-text" | "duplicate-text-fragment-id" | "missing-text" | "invalid-policy";
+interface AgenticMemoryContextPackingError {
+    readonly code: AgenticMemoryContextPackingErrorCode;
+    readonly message: string;
+    readonly index?: number;
+    readonly fragmentId?: FactId;
+    readonly value?: unknown;
+    readonly validationErrors?: readonly string[];
+    readonly cursor: AgenticMemoryContextPackingCursor;
+}
+interface AgenticMemoryContextPackingSnapshot {
+    readonly packedContext: AgenticMemoryPackedContext;
+    readonly status: AgenticMemoryContextPackingStatus;
+    readonly errors: readonly AgenticMemoryContextPackingError[];
+    readonly cursor: AgenticMemoryContextPackingCursor;
+}
+interface AgenticMemoryContextPackingBundle<T = unknown> {
+    readonly input: {
+        readonly context: Node<AgenticMemoryContext<T>>;
+        readonly texts: Node<readonly AgenticMemoryContextText[]>;
+        readonly policy: Node<AgenticMemoryContextPackingPolicy>;
+    };
+    readonly projection: Node<AgenticMemoryContextPackingSnapshot>;
+    readonly packedContext: Node<AgenticMemoryPackedContext>;
+    readonly status: Node<AgenticMemoryContextPackingStatus>;
+    readonly errors: Node<readonly AgenticMemoryContextPackingError[]>;
+    readonly cursor: Node<AgenticMemoryContextPackingCursor>;
+}
+interface AgenticMemoryContextPackingBundleOptions<T = unknown> {
+    readonly name?: string;
+    readonly context: Node<AgenticMemoryContext<T>>;
+    readonly texts: Node<readonly AgenticMemoryContextText[]>;
+    readonly policy: Node<AgenticMemoryContextPackingPolicy>;
+}
+interface AgenticMemoryBundle<T = unknown> {
+    readonly input: {
+        readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+        readonly query: Node<MemoryRetrievalQuery>;
+    };
+    readonly projection: Node<AgenticMemoryProjectionSnapshot<T>>;
+    readonly retrieval: MemoryRetrievalBundle<T>;
+    readonly retrievalSnapshot: Node<MemoryRetrievalSnapshot<T>>;
+    readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+    readonly fragments: Node<readonly MemoryFragment<T>[]>;
+    readonly sources: Node<readonly AgenticMemorySourceProjection[]>;
+    readonly indexed: Node<MemoryRetrievalIndex<T>>;
+    readonly ranked: Node<MemoryAnswer<T>>;
+    readonly context: Node<AgenticMemoryContext<T>>;
+    readonly status: Node<AgenticMemoryStatus>;
+    readonly errors: Node<readonly AgenticMemoryError[]>;
+    readonly retrievalStatus: Node<MemoryRetrievalStatus>;
+    readonly retrievalErrors: Node<readonly MemoryRetrievalError[]>;
+    readonly cursor: Node<MemoryRetrievalCursor>;
+}
+interface AgenticMemoryBundleOptions<T = unknown> {
+    readonly name?: string;
+    /** Explicit record-envelope input. Persistence, if needed, composes D161 outside this bundle. */
+    readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+    /** Explicit retrieval query input. */
+    readonly query: Node<MemoryRetrievalQuery>;
+}
+/**
+ * Compose graph-visible semantic-memory retrieval into an agentic-memory v0 bundle.
+ *
+ * The returned nodes are ordinary graph nodes with declared deps and DATA facts.
+ * Invalid record envelopes and duplicate record ids stay graph-visible through
+ * solution-level status/errors DATA facts. The lower retrieval bundle remains
+ * visible and receives only projected MemoryFragment values.
+ */
+declare function agenticMemoryBundle<T = unknown>(graph: Graph, opts: AgenticMemoryBundleOptions<T>): AgenticMemoryBundle<T>;
+/**
+ * D165 solution-level KG assertion projection.
+ *
+ * Records and explicit assertion drafts stay visible as declared deps. This
+ * bundle validates references and shape, then emits DATA facts only; it does
+ * not extract assertions, call LLMs, read/write storage, or mutate topology.
+ */
+declare function agenticMemoryKgProjectionBundle(graph: Graph, opts: AgenticMemoryKgProjectionBundleOptions): AgenticMemoryKgProjectionBundle;
+/** Build a D166 strict-JSON frame from an in-memory AgenticMemoryRecord. */
+declare function agenticMemoryRecordFrame<TJson extends StrictJsonValue>(record: AgenticMemoryRecord<TJson>): AgenticMemoryRecordFrame<TJson>;
+/** Assert and snapshot a decoded D166 record frame. Unknown fields fail honestly. */
+declare function assertAgenticMemoryRecordFrame<TJson extends StrictJsonValue = StrictJsonValue>(value: unknown): AgenticMemoryRecordFrame<TJson>;
+/** Strict canonical JSON codec for D166 AgenticMemoryRecordFrame values. */
+declare function agenticMemoryRecordFrameCodec<TJson extends StrictJsonValue = StrictJsonValue>(): Codec<AgenticMemoryRecordFrame<TJson>>;
+/** Strict canonical JSON codec that persists records and decodes bigint fields back to bigint. */
+declare function agenticMemoryRecordCodec<TJson extends StrictJsonValue = StrictJsonValue>(): Codec<AgenticMemoryRecord<TJson>>;
+/**
+ * D167 solution-level retention command projection.
+ *
+ * Archive/restore/setPersistenceLevel are derived views over current records;
+ * requestConsolidation emits request facts only.
+ */
+declare function agenticMemoryRetentionBundle<T = unknown>(graph: Graph, opts: AgenticMemoryRetentionBundleOptions<T>): AgenticMemoryRetentionBundle<T>;
+/**
+ * D171 consolidation outcome projection.
+ *
+ * The bundle does not execute consolidation. External adapters may publish
+ * outcome facts, and this projection turns them into visible result/proposal
+ * facts for downstream record-creation policy.
+ */
+declare function agenticMemoryConsolidationBundle<T = unknown>(graph: Graph, opts: AgenticMemoryConsolidationBundleOptions<T>): AgenticMemoryConsolidationBundle<T>;
+/** D168 deterministic context-packing bundle over explicit context text facts. */
+declare function agenticMemoryContextPackingBundle<T = unknown>(graph: Graph, opts: AgenticMemoryContextPackingBundleOptions<T>): AgenticMemoryContextPackingBundle<T>;
+
+export { type AgenticMemoryRetentionCursor as $, AGENTIC_MEMORY_RECORD_FRAME_FORMAT as A, type AgenticMemoryContextState as B, type AgenticMemoryContextText as C, type AgenticMemoryError as D, type AgenticMemoryErrorCode as E, type AgenticMemoryFragmentFrame as F, type AgenticMemoryKgAssertionDraft as G, type AgenticMemoryKgProjectionBundle as H, type AgenticMemoryKgProjectionBundleOptions as I, type AgenticMemoryKgProjectionCursor as J, type AgenticMemoryKgProjectionError as K, type AgenticMemoryKgProjectionErrorCode as L, type AgenticMemoryKgProjectionSnapshot as M, type AgenticMemoryKgProjectionStatus as N, type AgenticMemoryKgProjectionStatusState as O, type AgenticMemoryKind as P, type AgenticMemoryPackedContext as Q, type AgenticMemoryPackedContextEntry as R, type AgenticMemoryPersistenceLevel as S, type AgenticMemoryProjectionCursor as T, type AgenticMemoryProjectionSnapshot as U, type AgenticMemoryRecord as V, type AgenticMemoryRecordFrame as W, type AgenticMemoryRecordMetadata as X, type AgenticMemoryRetentionBundle as Y, type AgenticMemoryRetentionBundleOptions as Z, type AgenticMemoryRetentionCommand as _, AGENTIC_MEMORY_RECORD_FRAME_VERSION as a, type AgenticMemoryRetentionError as a0, type AgenticMemoryRetentionErrorCode as a1, type AgenticMemoryRetentionSnapshot as a2, type AgenticMemoryRetentionStatus as a3, type AgenticMemoryScope as a4, type AgenticMemorySourceProjection as a5, type AgenticMemoryStatus as a6, type AgenticMemoryStatusState as a7, type AgenticMemoryStrictJsonValue as a8, agenticMemoryBundle as a9, agenticMemoryConsolidationBundle as aa, agenticMemoryContextPackingBundle as ab, agenticMemoryKgProjectionBundle as ac, agenticMemoryRecordCodec as ad, agenticMemoryRecordFrame as ae, agenticMemoryRecordFrameCodec as af, agenticMemoryRetentionBundle as ag, assertAgenticMemoryRecordFrame as ah, type AgenticMemoryArtifactKind as b, type AgenticMemoryBundle as c, type AgenticMemoryBundleOptions as d, type AgenticMemoryConsolidationBundle as e, type AgenticMemoryConsolidationBundleOptions as f, type AgenticMemoryConsolidationCommand as g, type AgenticMemoryConsolidationCursor as h, type AgenticMemoryConsolidationError as i, type AgenticMemoryConsolidationErrorCode as j, type AgenticMemoryConsolidationOutcome as k, type AgenticMemoryConsolidationRecordDraft as l, type AgenticMemoryConsolidationRequest as m, type AgenticMemoryConsolidationResult as n, type AgenticMemoryConsolidationSnapshot as o, type AgenticMemoryConsolidationStatus as p, type AgenticMemoryContext as q, type AgenticMemoryContextEntry as r, type AgenticMemoryContextPackingBundle as s, type AgenticMemoryContextPackingBundleOptions as t, type AgenticMemoryContextPackingCursor as u, type AgenticMemoryContextPackingError as v, type AgenticMemoryContextPackingErrorCode as w, type AgenticMemoryContextPackingPolicy as x, type AgenticMemoryContextPackingSnapshot as y, type AgenticMemoryContextPackingStatus as z };

package/dist/capability-admission-B0BzqAm5.d.cts

@@ -0,0 +1,102 @@
+import { DataIssue } from './data/index.cjs';
+import { d as Graph } from './graph-DCEWh4T2.cjs';
+import { BoundaryCapabilityRef, BoundaryRole } from './inspection/boundary.cjs';
+import { N as Node } from './types-CcPIn7sy.cjs';
+import { S as SourceRef, v as AgentRuntimeAuditRecord } from './agent-runtime-DZTJ3C-p.cjs';
+
+/**
+ * Product-owned capability admission facts (D357).
+ *
+ * This helper consumes generic BoundaryCapabilityRef data and emits ordinary DATA
+ * facts for product admission state. It is not AutoPanel security, not a provider
+ * registry, and not protocol ERROR/tier/message semantics.
+ */
+
+type CapabilityAdmissionOutcome = "allow" | "block" | "defer";
+type CapabilityAdmissionState = "allowed" | "blocked" | "deferred";
+interface CapabilityAdmissionProposal {
+    readonly kind: "capability-admission-proposal";
+    readonly proposalId: string;
+    readonly subjectId: string;
+    readonly capability: BoundaryCapabilityRef;
+    readonly boundaryName?: string;
+    readonly role?: BoundaryRole;
+    readonly reason?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly proposedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface CapabilityAdmissionPolicy {
+    readonly kind: "capability-admission-policy";
+    readonly policyId: string;
+    readonly capabilityIds?: readonly string[];
+    readonly capabilityKinds?: readonly BoundaryCapabilityRef["kind"][];
+    readonly requiredOnly?: boolean;
+    readonly allowedOutcomes?: readonly CapabilityAdmissionOutcome[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface CapabilityAdmissionDecision {
+    readonly kind: "capability-admission-decision";
+    readonly decisionId: string;
+    readonly admissionId: string;
+    readonly proposalId: string;
+    readonly outcome: CapabilityAdmissionOutcome;
+    readonly policyId?: string;
+    readonly reason?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly decidedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface CapabilityAdmission {
+    readonly kind: "capability-admission";
+    readonly admissionId: string;
+    readonly proposalId: string;
+    readonly subjectId: string;
+    readonly capability: BoundaryCapabilityRef;
+    readonly state: CapabilityAdmissionState;
+    readonly decisionId: string;
+    readonly boundaryName?: string;
+    readonly role?: BoundaryRole;
+    readonly policyId?: string;
+    readonly reason?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly admittedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface CapabilityAdmissionStatus {
+    readonly kind: "capability-admission-status";
+    readonly statusId: string;
+    readonly state: "capability-admission-allowed" | "capability-admission-blocked" | "capability-admission-deferred" | "capability-admission-issue";
+    readonly proposalId?: string;
+    readonly admissionId?: string;
+    readonly subjectId?: string;
+    readonly capabilityId?: string;
+    readonly capabilityKind?: BoundaryCapabilityRef["kind"];
+    readonly policyId?: string;
+    readonly issues?: readonly DataIssue[];
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface CapabilityAdmissionViews {
+    readonly admissionsByProposal: ReadonlyMap<string, CapabilityAdmission>;
+    readonly admissionsBySubject: ReadonlyMap<string, readonly CapabilityAdmission[]>;
+    readonly issues: readonly DataIssue[];
+    readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+interface CapabilityAdmissionBundle {
+    readonly admissions: Node<CapabilityAdmission>;
+    readonly status: Node<CapabilityAdmissionStatus>;
+    readonly issues: Node<DataIssue>;
+    readonly audit: Node<AgentRuntimeAuditRecord>;
+    readonly views: Node<CapabilityAdmissionViews>;
+}
+declare function capabilityAdmissionProposal(opts: Omit<CapabilityAdmissionProposal, "kind">): CapabilityAdmissionProposal;
+declare function capabilityAdmissionProjector(graph: Graph, opts: {
+    readonly name?: string;
+    readonly proposals: Node<CapabilityAdmissionProposal>;
+    readonly decisions: Node<CapabilityAdmissionDecision>;
+    readonly admissionPolicies?: readonly Node<CapabilityAdmissionPolicy>[];
+    readonly now?: () => number;
+}): CapabilityAdmissionBundle;
+
+export { type CapabilityAdmission as C, type CapabilityAdmissionBundle as a, type CapabilityAdmissionDecision as b, type CapabilityAdmissionOutcome as c, type CapabilityAdmissionPolicy as d, type CapabilityAdmissionProposal as e, type CapabilityAdmissionState as f, type CapabilityAdmissionStatus as g, type CapabilityAdmissionViews as h, capabilityAdmissionProjector as i, capabilityAdmissionProposal as j };