@oscharko-dev/keiko-contracts 0.2.0

package/dist/memory-operations-validation.js

@@ -0,0 +1,267 @@
+// Pure validators for memory operation envelopes (Epic #204, Issue #205). Sibling of
+// `memory-validation.ts`. Retrieval and audit validators live in
+// `memory-retrieval-validation.ts` and `memory-audit-validation.ts` so each file stays
+// under the 400-LOC budget. No IO, no clock, no randomness.
+import { MEMORY_SENSITIVITIES, MEMORY_TYPES } from "./memory.js";
+import { validateMemoryProvenance, validateMemoryScope, validateMemoryStructuredPayload, validateMemoryValidityInterval, } from "./memory-validation.js";
+import { MEMORY_BODY_MAX_CHARS, MEMORY_RATIONALE_MAX_CHARS, MEMORY_REASON_MAX_CHARS, isFiniteNonNegativeNumber, isMember, isNonEmptyTrimmedString, isRecord, isSafeText, pushNestedErrors, validateMemoryIdString, validateRetentionHint, validateSchemaVersionLiteral, validateTags, } from "./memory-internal.js";
+// ─── Proposal ─────────────────────────────────────────────────────────────────
+function validateProposalOptionalFields(input, errors) {
+    if (input.payload !== undefined) {
+        pushNestedErrors("proposal", validateMemoryStructuredPayload(input.payload), errors);
+    }
+    validateTags("proposal.tags", input.tags, errors);
+    pushNestedErrors("proposal", validateMemoryProvenance(input.provenance), errors);
+    pushNestedErrors("proposal", validateMemoryValidityInterval(input.validity), errors);
+    if (input.retentionHint !== undefined) {
+        validateRetentionHint("proposal.retentionHint", input.retentionHint, errors);
+    }
+    if (input.captureReason !== undefined &&
+        !isSafeText(input.captureReason, MEMORY_RATIONALE_MAX_CHARS)) {
+        errors.push("proposal.captureReason must be a bounded control-free string when set");
+    }
+}
+export function validateMemoryProposal(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["proposal must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("proposal.proposalId", input.proposalId, errors);
+    if (!isFiniteNonNegativeNumber(input.proposedAt)) {
+        errors.push("proposal.proposedAt must be a finite non-negative number");
+    }
+    pushNestedErrors("proposal", validateMemoryScope(input.scope), errors);
+    if (!isMember(input.type, MEMORY_TYPES)) {
+        errors.push(`proposal.type must be one of ${MEMORY_TYPES.join("|")}`);
+    }
+    if (!isSafeText(input.body, MEMORY_BODY_MAX_CHARS)) {
+        errors.push("proposal.body must be a bounded control-free non-empty string");
+    }
+    validateProposalOptionalFields(input, errors);
+    if (input.initialStatus !== "proposed") {
+        errors.push('proposal.initialStatus must be the literal "proposed"');
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Acceptance ───────────────────────────────────────────────────────────────
+function validateAcceptanceOverrides(input, errors) {
+    if (input.bodyOverride !== undefined && !isSafeText(input.bodyOverride, MEMORY_BODY_MAX_CHARS)) {
+        errors.push("acceptance.bodyOverride must be a bounded control-free string when set");
+    }
+    if (input.sensitivityOverride !== undefined &&
+        !isMember(input.sensitivityOverride, MEMORY_SENSITIVITIES)) {
+        errors.push(`acceptance.sensitivityOverride must be one of ${MEMORY_SENSITIVITIES.join("|")} when set`);
+    }
+    if (input.validityOverride !== undefined) {
+        pushNestedErrors("acceptance", validateMemoryValidityInterval(input.validityOverride), errors);
+    }
+    if (input.reviewerNote !== undefined &&
+        !isSafeText(input.reviewerNote, MEMORY_RATIONALE_MAX_CHARS)) {
+        errors.push("acceptance.reviewerNote must be a bounded control-free string when set");
+    }
+}
+export function validateMemoryAcceptance(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["acceptance must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("acceptance.proposalId", input.proposalId, errors);
+    validateMemoryIdString("acceptance.mintedMemoryId", input.mintedMemoryId, errors);
+    validateMemoryIdString("acceptance.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.acceptedAt)) {
+        errors.push("acceptance.acceptedAt must be a finite non-negative number");
+    }
+    validateAcceptanceOverrides(input, errors);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Rejection ────────────────────────────────────────────────────────────────
+export function validateMemoryRejection(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["rejection must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("rejection.proposalId", input.proposalId, errors);
+    validateMemoryIdString("rejection.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.rejectedAt)) {
+        errors.push("rejection.rejectedAt must be a finite non-negative number");
+    }
+    if (!isSafeText(input.reason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push("rejection.reason must be a bounded control-free non-empty string");
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Update ───────────────────────────────────────────────────────────────────
+const UPDATE_OPTIONAL_FIELDS = [
+    "bodyPatch",
+    "payloadPatch",
+    "tagsPatch",
+    "validityPatch",
+    "sensitivityPatch",
+    "retentionHintPatch",
+];
+function countUpdatePatches(input) {
+    let count = 0;
+    for (const field of UPDATE_OPTIONAL_FIELDS) {
+        if (input[field] !== undefined) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function validateUpdatePatchFields(input, errors) {
+    if (input.bodyPatch !== undefined && !isSafeText(input.bodyPatch, MEMORY_BODY_MAX_CHARS)) {
+        errors.push("update.bodyPatch must be a bounded control-free string when set");
+    }
+    if (input.payloadPatch !== undefined) {
+        pushNestedErrors("update", validateMemoryStructuredPayload(input.payloadPatch), errors);
+    }
+    if (input.tagsPatch !== undefined) {
+        validateTags("update.tagsPatch", input.tagsPatch, errors);
+    }
+    if (input.validityPatch !== undefined) {
+        pushNestedErrors("update", validateMemoryValidityInterval(input.validityPatch), errors);
+    }
+    if (input.sensitivityPatch !== undefined &&
+        !isMember(input.sensitivityPatch, MEMORY_SENSITIVITIES)) {
+        errors.push(`update.sensitivityPatch must be one of ${MEMORY_SENSITIVITIES.join("|")} when set`);
+    }
+    if (input.retentionHintPatch !== undefined) {
+        validateRetentionHint("update.retentionHintPatch", input.retentionHintPatch, errors);
+    }
+}
+export function validateMemoryUpdate(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["update must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("update.memoryId", input.memoryId, errors);
+    validateMemoryIdString("update.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.updatedAt)) {
+        errors.push("update.updatedAt must be a finite non-negative number");
+    }
+    validateUpdatePatchFields(input, errors);
+    if (countUpdatePatches(input) === 0) {
+        errors.push("update must change at least one field");
+    }
+    if (input.reviewerNote !== undefined &&
+        !isSafeText(input.reviewerNote, MEMORY_RATIONALE_MAX_CHARS)) {
+        errors.push("update.reviewerNote must be a bounded control-free string when set");
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Supersession ─────────────────────────────────────────────────────────────
+export function validateMemorySupersession(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["supersession must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("supersession.oldMemoryId", input.oldMemoryId, errors);
+    validateMemoryIdString("supersession.newMemoryId", input.newMemoryId, errors);
+    if (isNonEmptyTrimmedString(input.oldMemoryId) &&
+        isNonEmptyTrimmedString(input.newMemoryId) &&
+        input.oldMemoryId === input.newMemoryId) {
+        errors.push("supersession.oldMemoryId and supersession.newMemoryId must differ");
+    }
+    validateMemoryIdString("supersession.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.supersededAt)) {
+        errors.push("supersession.supersededAt must be a finite non-negative number");
+    }
+    if (!isSafeText(input.reason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push("supersession.reason must be a bounded control-free non-empty string");
+    }
+    if (input.edgeKind !== "supersedes") {
+        errors.push('supersession.edgeKind must be the literal "supersedes"');
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Pin / unpin / archive ────────────────────────────────────────────────────
+function validatePinOrUnpinShape(noun, timestampField, input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: [`${noun} must be an object`] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString(`${noun}.memoryId`, input.memoryId, errors);
+    validateMemoryIdString(`${noun}.reviewerId`, input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input[timestampField])) {
+        errors.push(`${noun}.${timestampField} must be a finite non-negative number`);
+    }
+    if (input.reason !== undefined && !isSafeText(input.reason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push(`${noun}.reason must be a bounded control-free string when set`);
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+export function validateMemoryPin(input) {
+    return validatePinOrUnpinShape("pin", "pinnedAt", input);
+}
+export function validateMemoryUnpin(input) {
+    return validatePinOrUnpinShape("unpin", "unpinnedAt", input);
+}
+export function validateMemoryArchive(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["archive must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("archive.memoryId", input.memoryId, errors);
+    validateMemoryIdString("archive.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.archivedAt)) {
+        errors.push("archive.archivedAt must be a finite non-negative number");
+    }
+    if (input.reason !== undefined && !isSafeText(input.reason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push("archive.reason must be a bounded control-free string when set");
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Forget ───────────────────────────────────────────────────────────────────
+// The destructive-acknowledgement flag is pinned to the literal `true` at the type level,
+// so structural success is also semantic acknowledgement: a caller cannot ship a forget
+// envelope without explicit acknowledgement.
+export function validateMemoryForget(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["forget must be an object"] };
+    }
+    const errors = [];
+    validateSchemaVersionLiteral(input, errors);
+    validateMemoryIdString("forget.memoryId", input.memoryId, errors);
+    validateMemoryIdString("forget.reviewerId", input.reviewerId, errors);
+    if (!isFiniteNonNegativeNumber(input.forgottenAt)) {
+        errors.push("forget.forgottenAt must be a finite non-negative number");
+    }
+    if (!isSafeText(input.reason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push("forget.reason must be a bounded control-free non-empty string");
+    }
+    if (input.userAcknowledgedDestructive !== true) {
+        errors.push("forget.userAcknowledgedDestructive must be the literal true");
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}

package/dist/memory-operations.d.ts

@@ -0,0 +1,156 @@
+import type { MemoryAuditActionKind, MemoryAuditRecordId, MemoryEdgeId, MemoryEdgeKind, MemoryId, MemoryProposalId, MemoryReviewerId, MemoryScope, MemorySensitivity, MemoryStatus, MemoryType } from "./memory.js";
+import type { MemoryProvenance, MemoryRetentionHint, MemoryStructuredPayload, MemoryValidityInterval } from "./memory-records.js";
+export interface MemoryProposal {
+    readonly schemaVersion: "1";
+    readonly proposalId: MemoryProposalId;
+    readonly proposedAt: number;
+    readonly scope: MemoryScope;
+    readonly type: MemoryType;
+    readonly body: string;
+    readonly payload?: MemoryStructuredPayload;
+    readonly tags: readonly string[];
+    readonly provenance: MemoryProvenance;
+    readonly validity: MemoryValidityInterval;
+    readonly retentionHint?: MemoryRetentionHint;
+    readonly initialStatus: "proposed";
+    readonly captureReason?: string;
+}
+export interface MemoryAcceptance {
+    readonly schemaVersion: "1";
+    readonly proposalId: MemoryProposalId;
+    readonly mintedMemoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly acceptedAt: number;
+    readonly bodyOverride?: string;
+    readonly sensitivityOverride?: MemorySensitivity;
+    readonly validityOverride?: MemoryValidityInterval;
+    readonly reviewerNote?: string;
+}
+export interface MemoryRejection {
+    readonly schemaVersion: "1";
+    readonly proposalId: MemoryProposalId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly rejectedAt: number;
+    readonly reason: string;
+}
+export interface MemoryUpdate {
+    readonly schemaVersion: "1";
+    readonly memoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly updatedAt: number;
+    readonly bodyPatch?: string;
+    readonly payloadPatch?: MemoryStructuredPayload;
+    readonly tagsPatch?: readonly string[];
+    readonly validityPatch?: MemoryValidityInterval;
+    readonly sensitivityPatch?: MemorySensitivity;
+    readonly retentionHintPatch?: MemoryRetentionHint;
+    readonly reviewerNote?: string;
+}
+export interface MemorySupersession {
+    readonly schemaVersion: "1";
+    readonly oldMemoryId: MemoryId;
+    readonly newMemoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly supersededAt: number;
+    readonly reason: string;
+    readonly edgeKind: "supersedes";
+}
+export interface MemoryPin {
+    readonly schemaVersion: "1";
+    readonly memoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly pinnedAt: number;
+    readonly reason?: string;
+}
+export interface MemoryUnpin {
+    readonly schemaVersion: "1";
+    readonly memoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly unpinnedAt: number;
+    readonly reason?: string;
+}
+export interface MemoryArchive {
+    readonly schemaVersion: "1";
+    readonly memoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly archivedAt: number;
+    readonly reason?: string;
+}
+export interface MemoryForget {
+    readonly schemaVersion: "1";
+    readonly memoryId: MemoryId;
+    readonly reviewerId: MemoryReviewerId;
+    readonly forgottenAt: number;
+    readonly reason: string;
+    readonly userAcknowledgedDestructive: true;
+}
+export interface MemoryRetrievalRequest {
+    readonly schemaVersion: "1";
+    readonly requestedAt: number;
+    readonly scopes: readonly MemoryScope[];
+    readonly typeFilter?: readonly MemoryType[];
+    readonly statusFilter?: readonly MemoryStatus[];
+    readonly textQuery?: string;
+    readonly tagsFilter?: readonly string[];
+    readonly maxResults?: number;
+    readonly maxBodyChars?: number;
+    readonly includeArchived?: boolean;
+    readonly includeSuperseded?: boolean;
+}
+export type MemoryAuditAction = {
+    readonly kind: "proposed";
+    readonly proposalId: MemoryProposalId;
+    readonly scope: MemoryScope;
+} | {
+    readonly kind: "accepted";
+    readonly proposalId: MemoryProposalId;
+    readonly memoryId: MemoryId;
+    readonly scope: MemoryScope;
+} | {
+    readonly kind: "rejected";
+    readonly proposalId: MemoryProposalId;
+    readonly reason: string;
+} | {
+    readonly kind: "updated";
+    readonly memoryId: MemoryId;
+    readonly fieldsChanged: readonly MemoryUpdateField[];
+} | {
+    readonly kind: "superseded";
+    readonly oldMemoryId: MemoryId;
+    readonly newMemoryId: MemoryId;
+    readonly edgeId: MemoryEdgeId;
+    readonly edgeKind: MemoryEdgeKind;
+} | {
+    readonly kind: "pinned";
+    readonly memoryId: MemoryId;
+} | {
+    readonly kind: "unpinned";
+    readonly memoryId: MemoryId;
+} | {
+    readonly kind: "archived";
+    readonly memoryId: MemoryId;
+} | {
+    readonly kind: "forgotten";
+    readonly memoryId: MemoryId;
+    readonly scope: MemoryScope;
+    readonly reason: string;
+} | {
+    readonly kind: "retrieved";
+    readonly scopes: readonly MemoryScope[];
+    readonly matchedMemoryIds: readonly MemoryId[];
+};
+export type MemoryUpdateField = "body" | "payload" | "tags" | "validity" | "sensitivity" | "retentionHint";
+export declare const MEMORY_UPDATE_FIELDS: readonly MemoryUpdateField[];
+export type MemoryAuditInitiatorSurface = "memory-center" | "conversation-center" | "workflow" | "consolidation" | "retention" | "system";
+export declare const MEMORY_AUDIT_INITIATOR_SURFACES: readonly MemoryAuditInitiatorSurface[];
+export interface MemoryAuditRecord {
+    readonly id: MemoryAuditRecordId;
+    readonly schemaVersion: "1";
+    readonly actionKind: MemoryAuditActionKind;
+    readonly action: MemoryAuditAction;
+    readonly initiatorSurface: MemoryAuditInitiatorSurface;
+    readonly initiatorReviewerId?: MemoryReviewerId;
+    readonly occurredAt: number;
+    readonly summary: string;
+}
+//# sourceMappingURL=memory-operations.d.ts.map

package/dist/memory-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-operations.d.ts","sourceRoot":"","sources":["../src/memory-operations.ts"],"names":[],"mappings":"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"}

package/dist/memory-operations.js

@@ -0,0 +1,29 @@
+// Operation envelopes for the Governed Enterprise Memory Vault (Epic #204, Issue #205).
+// Pure types only — no IO, no clock, no randomness. Leaf-package rule (ADR-0019 direction
+// 1): no `@oscharko-dev/keiko-*` imports.
+//
+// Each operation carries the minimum data the next layer needs to evaluate it. The
+// validation layer (memory-validation.ts) checks structural well-formedness, status
+// transition legality, and provenance presence; authorization, persistence, and
+// side-effects belong to downstream packages and are explicitly out of scope here.
+//
+// Audit invariant: `MemoryAuditRecord` MUST NOT carry raw memory content. It references
+// affected memories by ID and pins a short, non-secret rationale string. This keeps the
+// audit ledger redaction-safe and lets the audit boundary (#214) ship audit summaries
+// across the wire without re-redacting.
+export const MEMORY_UPDATE_FIELDS = [
+    "body",
+    "payload",
+    "tags",
+    "validity",
+    "sensitivity",
+    "retentionHint",
+];
+export const MEMORY_AUDIT_INITIATOR_SURFACES = [
+    "memory-center",
+    "conversation-center",
+    "workflow",
+    "consolidation",
+    "retention",
+    "system",
+];

package/dist/memory-record-validation.d.ts

@@ -0,0 +1,10 @@
+import type { MemoryEdge, MemoryRecord, MemoryStructuredPayload, MemoryValidityInterval } from "./memory-records.js";
+import type { MemoryProvenance } from "./memory-records.js";
+import type { MemoryScope, MemoryType } from "./memory.js";
+import { type MemoryValidation } from "./memory-validation.js";
+export declare function validateMemoryRecord(input: unknown): MemoryValidation<MemoryRecord>;
+export declare function isMemoryRecord(value: unknown): value is MemoryRecord;
+export declare function isMemoryEdge(value: unknown): value is MemoryEdge;
+export declare function assertNeverMemoryType(value: never): never;
+export type { MemoryEdge, MemoryProvenance, MemoryRecord, MemoryScope, MemoryStructuredPayload, MemoryType, MemoryValidityInterval, };
+//# sourceMappingURL=memory-record-validation.d.ts.map

package/dist/memory-record-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-record-validation.d.ts","sourceRoot":"","sources":["../src/memory-record-validation.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAuEhC,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAmBnF;AAOD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAKD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAEzD;AAKD,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,uBAAuB,EACvB,UAAU,EACV,sBAAsB,GACvB,CAAC"}

package/dist/memory-record-validation.js

@@ -0,0 +1,101 @@
+// Record-level schema validators and discriminator helpers for the Governed Enterprise
+// Memory Vault (Epic #204, Issue #205). Mirrors the `local-knowledge-schema-validation.ts`
+// pattern: takes an `unknown`, walks the structural shape, returns either a narrowed
+// `MemoryRecord` or a list of failed invariants.
+//
+// Also exports `isMemoryRecord`, `isMemoryEdge`, and `assertNeverMemoryType` — the three
+// helpers that prove the contract distinguishes durable memory from chat history,
+// connected-context KnowledgeCapsules, and local-knowledge records. The discriminator
+// surface is small and load-bearing: downstream packages call these at every trust
+// boundary so the four "things that look like text with provenance" do not collapse into
+// each other.
+import { MEMORY_SCHEMA_VERSION, MEMORY_STATUSES, MEMORY_TYPES } from "./memory.js";
+import { validateMemoryEdge, validateMemoryProvenance, validateMemoryScope, validateMemoryStructuredPayload, validateMemoryValidityInterval, } from "./memory-validation.js";
+import { MEMORY_BODY_MAX_CHARS, MEMORY_REASON_MAX_CHARS, isFiniteNonNegativeNumber, isMember, isNonEmptyTrimmedString, isRecord, isSafeText, pushNestedErrors, validateRetentionHint, validateTags, } from "./memory-internal.js";
+function validateRecordSchemaVersion(input, errors) {
+    if (input.schemaVersion !== MEMORY_SCHEMA_VERSION) {
+        errors.push(`record.schemaVersion must be the literal "${MEMORY_SCHEMA_VERSION}"`);
+    }
+}
+function validateRecordEnums(input, errors) {
+    if (!isMember(input.type, MEMORY_TYPES)) {
+        errors.push(`record.type must be one of ${MEMORY_TYPES.join("|")}`);
+    }
+    if (!isMember(input.status, MEMORY_STATUSES)) {
+        errors.push(`record.status must be one of ${MEMORY_STATUSES.join("|")}`);
+    }
+}
+function validateRecordTimestamps(input, errors) {
+    if (!isFiniteNonNegativeNumber(input.createdAt)) {
+        errors.push("record.createdAt must be a finite non-negative number");
+    }
+    if (!isFiniteNonNegativeNumber(input.updatedAt)) {
+        errors.push("record.updatedAt must be a finite non-negative number");
+    }
+    if (isFiniteNonNegativeNumber(input.createdAt) &&
+        isFiniteNonNegativeNumber(input.updatedAt) &&
+        input.updatedAt < input.createdAt) {
+        errors.push("record.updatedAt must be greater than or equal to record.createdAt");
+    }
+}
+function validateRecordCoreShape(input, errors) {
+    if (!isNonEmptyTrimmedString(input.id)) {
+        errors.push("record.id must be a non-empty string");
+    }
+    if (!isSafeText(input.body, MEMORY_BODY_MAX_CHARS)) {
+        errors.push("record.body must be a bounded control-free non-empty string");
+    }
+    if (typeof input.pinned !== "boolean") {
+        errors.push("record.pinned must be a boolean");
+    }
+    if (input.staleReason !== undefined && !isSafeText(input.staleReason, MEMORY_REASON_MAX_CHARS)) {
+        errors.push("record.staleReason must be a bounded control-free string when set");
+    }
+    validateRecordEnums(input, errors);
+    validateRecordTimestamps(input, errors);
+}
+function validateRecordRetentionHint(input, errors) {
+    const hint = input.retentionHint;
+    if (hint === undefined) {
+        return;
+    }
+    validateRetentionHint("record.retentionHint", hint, errors);
+}
+// ─── validateMemoryRecord ─────────────────────────────────────────────────────
+export function validateMemoryRecord(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["record must be an object"] };
+    }
+    const errors = [];
+    validateRecordSchemaVersion(input, errors);
+    pushNestedErrors("record", validateMemoryScope(input.scope), errors);
+    validateRecordCoreShape(input, errors);
+    if (input.payload !== undefined) {
+        pushNestedErrors("record", validateMemoryStructuredPayload(input.payload), errors);
+    }
+    pushNestedErrors("record", validateMemoryProvenance(input.provenance), errors);
+    pushNestedErrors("record", validateMemoryValidityInterval(input.validity), errors);
+    validateTags("record.tags", input.tags, errors);
+    validateRecordRetentionHint(input, errors);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: input };
+}
+// ─── Predicates ───────────────────────────────────────────────────────────────
+// `isMemoryRecord` returns true only for values that pass the full record validator. The
+// distinction matters at the trust boundary: a chat message, a KnowledgeCapsule, or a
+// local-knowledge ChunkRecord may share some structural fields with a MemoryRecord but
+// none of them carries the (scope coordinate + provenance + status) triple together.
+export function isMemoryRecord(value) {
+    return validateMemoryRecord(value).ok;
+}
+export function isMemoryEdge(value) {
+    return validateMemoryEdge(value).ok;
+}
+// `assertNeverMemoryType` proves the type union is exhausted at compile time. Call this
+// in the default branch of a switch over `MemoryType`; a future contract version that
+// adds a new type produces a compile error here, not a silent runtime fall-through.
+export function assertNeverMemoryType(value) {
+    throw new Error(`unhandled MemoryType: ${String(value)}`);
+}

package/dist/memory-records.d.ts

@@ -0,0 +1,66 @@
+import type { ConversationId, EvidenceManifestId, MemoryEdgeId, MemoryEdgeKind, MemoryId, MemoryScope, MemorySensitivity, MemorySourceKind, MemoryStatus, MemoryType, WorkflowRunId } from "./memory.js";
+export interface MemoryModelIdentity {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly modelRevision?: string;
+}
+export interface MemoryProvenance {
+    readonly sourceKind: MemorySourceKind;
+    readonly sourceConversationId?: ConversationId;
+    readonly sourceWorkflowRunId?: WorkflowRunId;
+    readonly sourceEvidenceManifestId?: EvidenceManifestId;
+    readonly capturedAt: number;
+    readonly modelIdentity?: MemoryModelIdentity;
+    readonly confidence: number;
+    readonly sensitivity: MemorySensitivity;
+    readonly captureRationale?: string;
+}
+export interface MemoryValidityInterval {
+    readonly validFrom: number;
+    readonly validUntil?: number;
+}
+export interface MemoryRetentionHint {
+    readonly policyKey: string;
+    readonly retainUntil?: number;
+    readonly notes?: string;
+}
+export interface MemoryRecord {
+    readonly id: MemoryId;
+    readonly schemaVersion: "1";
+    readonly scope: MemoryScope;
+    readonly type: MemoryType;
+    readonly body: string;
+    readonly payload?: MemoryStructuredPayload;
+    readonly provenance: MemoryProvenance;
+    readonly validity: MemoryValidityInterval;
+    readonly status: MemoryStatus;
+    readonly pinned: boolean;
+    readonly staleReason?: string;
+    readonly retentionHint?: MemoryRetentionHint;
+    readonly tags: readonly string[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export type MemoryStructuredPayload = {
+    readonly kind: "string-list";
+    readonly items: readonly string[];
+} | {
+    readonly kind: "key-value";
+    readonly entries: readonly {
+        readonly key: string;
+        readonly value: string;
+    }[];
+};
+export type MemoryStructuredPayloadKind = MemoryStructuredPayload["kind"];
+export declare const MEMORY_STRUCTURED_PAYLOAD_KINDS: readonly MemoryStructuredPayloadKind[];
+export interface MemoryEdge {
+    readonly id: MemoryEdgeId;
+    readonly schemaVersion: "1";
+    readonly fromMemoryId: MemoryId;
+    readonly toMemoryId: MemoryId;
+    readonly kind: MemoryEdgeKind;
+    readonly createdAt: number;
+    readonly confidence?: number;
+    readonly provenanceSummary?: string;
+}
+//# sourceMappingURL=memory-records.d.ts.map

package/dist/memory-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-records.d.ts","sourceRoot":"","sources":["../src/memory-records.ts"],"names":[],"mappings":"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"}