@aletheia-labs/core 0.1.0

package/dist/types/human-receipt.js

@@ -0,0 +1,41 @@
+/**
+ * Human-readable receipt (specs/memory-authority-receipt-v0.md §"Canonical fields").
+ *
+ * The verbose YAML/Markdown form for audits and human handoffs. Less compact
+ * than CompressedReceipt but carries the same authority semantics.
+ */
+import { z } from 'zod';
+import { ActionClassSchema, EffectBoundarySchema, FreshnessSchema, LineageCompletenessSchema, PromotionBoundarySchema, ReadinessBoundarySchema, RiskTierSchema, TargetStatusSchema, } from './enums.js';
+import { IsoTimestampSchema, SourceArtifactIdSchema, SourcePathSchema } from './primitives.js';
+/**
+ * The "nextAllowedAction" sub-object of a human-readable receipt.
+ * Spec rule: must be exact; generic "continue" is not authority.
+ */
+export const NextAllowedActionSchema = z.object({
+    /** Specific verb the receiver is allowed to take. */
+    action: ActionClassSchema,
+    /** Exact next target (e.g. file path, fixture id). */
+    target: z.string().min(1).max(512),
+    /** The source target this succeeds. */
+    successorOf: z.string().min(1).max(512),
+    /** Whether re-running the action is allowed. */
+    redoAllowed: z.boolean(),
+});
+export const HumanReadableReceiptSchema = z.object({
+    sourceArtifactId: SourceArtifactIdSchema,
+    sourceArtifactPath: SourcePathSchema,
+    producedAt: IsoTimestampSchema,
+    receiverFreshness: FreshnessSchema,
+    targetStatus: TargetStatusSchema,
+    readinessBoundary: ReadinessBoundarySchema,
+    effectBoundary: EffectBoundarySchema,
+    promotionBoundary: PromotionBoundarySchema,
+    lineageCompleteness: LineageCompletenessSchema,
+    riskTier: RiskTierSchema,
+    nextAllowedAction: NextAllowedActionSchema,
+    /** How the claim was checked (free text, audit only). */
+    validation: z.string().min(1).max(2048),
+    /** Local/shadow safety result string (audit only). */
+    safetyResult: z.string().min(1).max(2048),
+});
+//# sourceMappingURL=human-receipt.js.map

package/dist/types/human-receipt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-receipt.js","sourceRoot":"","sources":["../../src/types/human-receipt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE/F;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,qDAAqD;IACrD,MAAM,EAAE,iBAAiB;IACzB,sDAAsD;IACtD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAClC,uCAAuC;IACvC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IACvC,gDAAgD;IAChD,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE;CACzB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,gBAAgB,EAAE,sBAAsB;IACxC,kBAAkB,EAAE,gBAAgB;IACpC,UAAU,EAAE,kBAAkB;IAC9B,iBAAiB,EAAE,eAAe;IAClC,YAAY,EAAE,kBAAkB;IAChC,iBAAiB,EAAE,uBAAuB;IAC1C,cAAc,EAAE,oBAAoB;IACpC,iBAAiB,EAAE,uBAAuB;IAC1C,mBAAmB,EAAE,yBAAyB;IAC9C,QAAQ,EAAE,cAAc;IACxB,iBAAiB,EAAE,uBAAuB;IAC1C,yDAAyD;IACzD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;IACvC,sDAAsD;IACtD,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;CAC1C,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Re-exports every domain type and schema.
+ *
+ * Convention:
+ *   - `FooSchema` — zod schema (use for parsing untrusted input).
+ *   - `Foo`       — TypeScript type (use as function signatures and storage).
+ *
+ * Hand-built values (when you trust the input) get the type.
+ * Anything coming over a wire, from disk, or from an LLM goes through the schema.
+ */
+export * from './primitives.js';
+export * from './enums.js';
+export * from './keys.js';
+export * from './status-transitions.js';
+export * from './event.js';
+export * from './compressed-receipt.js';
+export * from './human-receipt.js';
+export * from './coverage.js';
+export * from './memory-atom.js';
+export * from './memory-proposal.js';
+export * from './conflict.js';
+export * from './action.js';
+export * from './decision.js';
+export * from './packet.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,25 @@
+/**
+ * Re-exports every domain type and schema.
+ *
+ * Convention:
+ *   - `FooSchema` — zod schema (use for parsing untrusted input).
+ *   - `Foo`       — TypeScript type (use as function signatures and storage).
+ *
+ * Hand-built values (when you trust the input) get the type.
+ * Anything coming over a wire, from disk, or from an LLM goes through the schema.
+ */
+export * from './primitives.js';
+export * from './enums.js';
+export * from './keys.js';
+export * from './status-transitions.js';
+export * from './event.js';
+export * from './compressed-receipt.js';
+export * from './human-receipt.js';
+export * from './coverage.js';
+export * from './memory-atom.js';
+export * from './memory-proposal.js';
+export * from './conflict.js';
+export * from './action.js';
+export * from './decision.js';
+export * from './packet.js';
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dist/types/keys.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Canonical string keys for Scope and Visibility.
+ *
+ * Any storage backend needs a single-string representation of these
+ * discriminated unions for indexing and permission filtering. Defining the
+ * canonical form once in `core` guarantees every backend agrees on it.
+ *
+ * Format is irreversible-by-design: a parser is provided, but storage layers
+ * should keep the original JSON alongside the key so the round-trip is exact.
+ */
+import type { Scope, Visibility } from './enums.js';
+/**
+ * Visibility → string key.
+ *   private:agent      → "private:agent"
+ *   private:user       → "private:user"
+ *   team               → "team:<name>"
+ *   global:safe        → "global:safe"
+ *   sealed:sensitive   → "sealed:sensitive"
+ *   ephemeral          → "ephemeral"
+ */
+export declare function visibilityKey(v: Visibility): string;
+/**
+ * Scope → string key.
+ *   local      → "local"
+ *   project    → "project:<projectId>"
+ *   user       → "user:<userId>"
+ *   team       → "team:<teamId>"
+ *   global     → "global"
+ */
+export declare function scopeKey(s: Scope): string;
+//# sourceMappingURL=keys.d.ts.map

package/dist/types/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/types/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAWnD;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAYzC"}

package/dist/types/keys.js

@@ -0,0 +1,53 @@
+/**
+ * Canonical string keys for Scope and Visibility.
+ *
+ * Any storage backend needs a single-string representation of these
+ * discriminated unions for indexing and permission filtering. Defining the
+ * canonical form once in `core` guarantees every backend agrees on it.
+ *
+ * Format is irreversible-by-design: a parser is provided, but storage layers
+ * should keep the original JSON alongside the key so the round-trip is exact.
+ */
+/**
+ * Visibility → string key.
+ *   private:agent      → "private:agent"
+ *   private:user       → "private:user"
+ *   team               → "team:<name>"
+ *   global:safe        → "global:safe"
+ *   sealed:sensitive   → "sealed:sensitive"
+ *   ephemeral          → "ephemeral"
+ */
+export function visibilityKey(v) {
+    switch (v.kind) {
+        case 'private:agent':
+        case 'private:user':
+        case 'global:safe':
+        case 'sealed:sensitive':
+        case 'ephemeral':
+            return v.kind;
+        case 'team':
+            return `team:${v.name}`;
+    }
+}
+/**
+ * Scope → string key.
+ *   local      → "local"
+ *   project    → "project:<projectId>"
+ *   user       → "user:<userId>"
+ *   team       → "team:<teamId>"
+ *   global     → "global"
+ */
+export function scopeKey(s) {
+    switch (s.kind) {
+        case 'local':
+        case 'global':
+            return s.kind;
+        case 'project':
+            return `project:${s.projectId}`;
+        case 'user':
+            return `user:${s.userId}`;
+        case 'team':
+            return `team:${s.teamId}`;
+    }
+}
+//# sourceMappingURL=keys.js.map

package/dist/types/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../src/types/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,CAAa;IACzC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,eAAe,CAAC;QACrB,KAAK,cAAc,CAAC;QACpB,KAAK,aAAa,CAAC;QACnB,KAAK,kBAAkB,CAAC;QACxB,KAAK,WAAW;YACd,OAAO,CAAC,CAAC,IAAI,CAAC;QAChB,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC5B,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAQ;IAC/B,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,OAAO,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,CAAC,CAAC,IAAI,CAAC;QAChB,KAAK,SAAS;YACZ,OAAO,WAAW,CAAC,CAAC,SAAS,EAAE,CAAC;QAClC,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,CAAC;AACH,CAAC"}

package/dist/types/memory-atom.d.ts

@@ -0,0 +1,291 @@
+/**
+ * MemoryAtom — the smallest actionable memory unit.
+ * Source: specs/aletheia-memory-authority-v0.md §4.
+ *
+ * Atoms are append-only. A "modification" produces a successor atom with a
+ * `supersedes` link. Status transitions are tracked separately (Phase 2).
+ */
+import { z } from 'zod';
+/**
+ * Scores attached to a MemoryAtom.
+ *
+ * Hard rule from spec: "No single score is authoritative. `confidence` cannot
+ * override weak evidence, stale freshness, wrong scope, or missing permission."
+ *
+ * Scores inform routing and ranking; they NEVER substitute for receipt fields.
+ */
+export declare const MemoryScoresSchema: z.ZodObject<{
+    confidence: z.ZodNumber;
+    evidence: z.ZodNumber;
+    authority: z.ZodNumber;
+    freshness: z.ZodNumber;
+    stability: z.ZodNumber;
+    consensus: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    evidence: number;
+    authority: number;
+    freshness: number;
+    stability: number;
+    consensus: number;
+}, {
+    confidence: number;
+    evidence: number;
+    authority: number;
+    freshness: number;
+    stability: number;
+    consensus: number;
+}>;
+export type MemoryScores = z.infer<typeof MemoryScoresSchema>;
+/**
+ * A typed edge from one atom to another.
+ * The relation determines whether the link is informational (`derived_from`)
+ * or has authority implications (`supersedes`, `contradicts`).
+ */
+export declare const MemoryLinkSchema: z.ZodObject<{
+    relation: z.ZodEnum<["supports", "contradicts", "supersedes", "derived_from"]>;
+    targetMemoryId: z.ZodBranded<z.ZodString, "MemoryId">;
+}, "strip", z.ZodTypeAny, {
+    relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+    targetMemoryId: string & z.BRAND<"MemoryId">;
+}, {
+    relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+    targetMemoryId: string;
+}>;
+export type MemoryLink = z.infer<typeof MemoryLinkSchema>;
+export declare const MemoryAtomSchema: z.ZodObject<{
+    memoryId: z.ZodBranded<z.ZodString, "MemoryId">;
+    memoryType: z.ZodEnum<["observation", "claim", "preference", "policy", "decision", "task_state", "warning", "skill"]>;
+    /** The actual claim/observation/decision text. */
+    content: z.ZodString;
+    /** Which agent produced this atom (proposer, not authority). */
+    sourceAgentId: z.ZodBranded<z.ZodString, "AgentId">;
+    /** Raw events this atom is grounded in. */
+    sourceEventIds: z.ZodArray<z.ZodBranded<z.ZodString, "EventId">, "many">;
+    /** Other atoms this one is derived from (chain of summarization). */
+    sourceMemoryIds: z.ZodArray<z.ZodBranded<z.ZodString, "MemoryId">, "many">;
+    scope: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"local">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "local";
+    }, {
+        kind: "local";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "project";
+        projectId: string;
+    }, {
+        kind: "project";
+        projectId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"user">;
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "user";
+        userId: string;
+    }, {
+        kind: "user";
+        userId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"team">;
+        teamId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "team";
+        teamId: string;
+    }, {
+        kind: "team";
+        teamId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"global">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "global";
+    }, {
+        kind: "global";
+    }>]>;
+    visibility: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"private:agent">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "private:agent";
+    }, {
+        kind: "private:agent";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"private:user">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "private:user";
+    }, {
+        kind: "private:user";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"team">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "team";
+        name: string;
+    }, {
+        kind: "team";
+        name: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"global:safe">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "global:safe";
+    }, {
+        kind: "global:safe";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"sealed:sensitive">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "sealed:sensitive";
+    }, {
+        kind: "sealed:sensitive";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"ephemeral">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "ephemeral";
+    }, {
+        kind: "ephemeral";
+    }>]>;
+    status: z.ZodEnum<["candidate", "verified", "trusted", "deprecated", "rejected", "sealed", "human_required"]>;
+    scores: z.ZodObject<{
+        confidence: z.ZodNumber;
+        evidence: z.ZodNumber;
+        authority: z.ZodNumber;
+        freshness: z.ZodNumber;
+        stability: z.ZodNumber;
+        consensus: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        evidence: number;
+        authority: number;
+        freshness: number;
+        stability: number;
+        consensus: number;
+    }, {
+        confidence: number;
+        evidence: number;
+        authority: number;
+        freshness: number;
+        stability: number;
+        consensus: number;
+    }>;
+    /** When this atom became (or will become) valid. */
+    validFrom: z.ZodString;
+    /** When this atom expires; null means open-ended. */
+    validUntil: z.ZodNullable<z.ZodString>;
+    /** Last time the atom was explicitly re-confirmed. */
+    lastConfirmedAt: z.ZodNullable<z.ZodString>;
+    /** Graph edges to other atoms. */
+    links: z.ZodArray<z.ZodObject<{
+        relation: z.ZodEnum<["supports", "contradicts", "supersedes", "derived_from"]>;
+        targetMemoryId: z.ZodBranded<z.ZodString, "MemoryId">;
+    }, "strip", z.ZodTypeAny, {
+        relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+        targetMemoryId: string & z.BRAND<"MemoryId">;
+    }, {
+        relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+        targetMemoryId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: "candidate" | "verified" | "trusted" | "deprecated" | "rejected" | "sealed" | "human_required";
+    memoryId: string & z.BRAND<"MemoryId">;
+    memoryType: "observation" | "claim" | "preference" | "policy" | "decision" | "task_state" | "warning" | "skill";
+    content: string;
+    sourceAgentId: string & z.BRAND<"AgentId">;
+    sourceEventIds: (string & z.BRAND<"EventId">)[];
+    sourceMemoryIds: (string & z.BRAND<"MemoryId">)[];
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    visibility: {
+        kind: "private:agent";
+    } | {
+        kind: "private:user";
+    } | {
+        kind: "team";
+        name: string;
+    } | {
+        kind: "global:safe";
+    } | {
+        kind: "sealed:sensitive";
+    } | {
+        kind: "ephemeral";
+    };
+    scores: {
+        confidence: number;
+        evidence: number;
+        authority: number;
+        freshness: number;
+        stability: number;
+        consensus: number;
+    };
+    validFrom: string;
+    validUntil: string | null;
+    lastConfirmedAt: string | null;
+    links: {
+        relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+        targetMemoryId: string & z.BRAND<"MemoryId">;
+    }[];
+}, {
+    status: "candidate" | "verified" | "trusted" | "deprecated" | "rejected" | "sealed" | "human_required";
+    memoryId: string;
+    memoryType: "observation" | "claim" | "preference" | "policy" | "decision" | "task_state" | "warning" | "skill";
+    content: string;
+    sourceAgentId: string;
+    sourceEventIds: string[];
+    sourceMemoryIds: string[];
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    visibility: {
+        kind: "private:agent";
+    } | {
+        kind: "private:user";
+    } | {
+        kind: "team";
+        name: string;
+    } | {
+        kind: "global:safe";
+    } | {
+        kind: "sealed:sensitive";
+    } | {
+        kind: "ephemeral";
+    };
+    scores: {
+        confidence: number;
+        evidence: number;
+        authority: number;
+        freshness: number;
+        stability: number;
+        consensus: number;
+    };
+    validFrom: string;
+    validUntil: string | null;
+    lastConfirmedAt: string | null;
+    links: {
+        relation: "supports" | "contradicts" | "supersedes" | "derived_from";
+        targetMemoryId: string;
+    }[];
+}>;
+export type MemoryAtom = z.infer<typeof MemoryAtomSchema>;
+//# sourceMappingURL=memory-atom.d.ts.map

package/dist/types/memory-atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-atom.d.ts","sourceRoot":"","sources":["../../src/types/memory-atom.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,gBAAgB;;;IAG3B,kDAAkD;;IAElD,gEAAgE;;IAEhE,2CAA2C;;IAI3C,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMrE,oDAAoD;;IAEpD,qDAAqD;;IAErD,sDAAsD;;IAEtD,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElC,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/types/memory-atom.js

@@ -0,0 +1,62 @@
+/**
+ * MemoryAtom — the smallest actionable memory unit.
+ * Source: specs/aletheia-memory-authority-v0.md §4.
+ *
+ * Atoms are append-only. A "modification" produces a successor atom with a
+ * `supersedes` link. Status transitions are tracked separately (Phase 2).
+ */
+import { z } from 'zod';
+import { LinkRelationSchema, MemoryStatusSchema, MemoryTypeSchema, ScopeSchema, VisibilitySchema, } from './enums.js';
+import { AgentIdSchema, EventIdSchema, IsoTimestampSchema, MemoryIdSchema } from './primitives.js';
+/**
+ * Scores attached to a MemoryAtom.
+ *
+ * Hard rule from spec: "No single score is authoritative. `confidence` cannot
+ * override weak evidence, stale freshness, wrong scope, or missing permission."
+ *
+ * Scores inform routing and ranking; they NEVER substitute for receipt fields.
+ */
+export const MemoryScoresSchema = z.object({
+    confidence: z.number().min(0).max(1),
+    evidence: z.number().min(0).max(1),
+    authority: z.number().min(0).max(1),
+    freshness: z.number().min(0).max(1),
+    stability: z.number().min(0).max(1),
+    consensus: z.number().min(0).max(1),
+});
+/**
+ * A typed edge from one atom to another.
+ * The relation determines whether the link is informational (`derived_from`)
+ * or has authority implications (`supersedes`, `contradicts`).
+ */
+export const MemoryLinkSchema = z.object({
+    relation: LinkRelationSchema,
+    targetMemoryId: MemoryIdSchema,
+});
+export const MemoryAtomSchema = z.object({
+    memoryId: MemoryIdSchema,
+    memoryType: MemoryTypeSchema,
+    /** The actual claim/observation/decision text. */
+    content: z.string().min(1),
+    /** Which agent produced this atom (proposer, not authority). */
+    sourceAgentId: AgentIdSchema,
+    /** Raw events this atom is grounded in. */
+    sourceEventIds: z.array(EventIdSchema).min(1, {
+        message: 'an atom must reference at least one source event',
+    }),
+    /** Other atoms this one is derived from (chain of summarization). */
+    sourceMemoryIds: z.array(MemoryIdSchema),
+    scope: ScopeSchema,
+    visibility: VisibilitySchema,
+    status: MemoryStatusSchema,
+    scores: MemoryScoresSchema,
+    /** When this atom became (or will become) valid. */
+    validFrom: IsoTimestampSchema,
+    /** When this atom expires; null means open-ended. */
+    validUntil: IsoTimestampSchema.nullable(),
+    /** Last time the atom was explicitly re-confirmed. */
+    lastConfirmedAt: IsoTimestampSchema.nullable(),
+    /** Graph edges to other atoms. */
+    links: z.array(MemoryLinkSchema),
+});
+//# sourceMappingURL=memory-atom.js.map

package/dist/types/memory-atom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-atom.js","sourceRoot":"","sources":["../../src/types/memory-atom.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEnG;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACpC,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,QAAQ,EAAE,kBAAkB;IAC5B,cAAc,EAAE,cAAc;CAC/B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,QAAQ,EAAE,cAAc;IACxB,UAAU,EAAE,gBAAgB;IAC5B,kDAAkD;IAClD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,gEAAgE;IAChE,aAAa,EAAE,aAAa;IAC5B,2CAA2C;IAC3C,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE;QAC5C,OAAO,EAAE,kDAAkD;KAC5D,CAAC;IACF,qEAAqE;IACrE,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;IACxC,KAAK,EAAE,WAAW;IAClB,UAAU,EAAE,gBAAgB;IAC5B,MAAM,EAAE,kBAAkB;IAC1B,MAAM,EAAE,kBAAkB;IAC1B,oDAAoD;IACpD,SAAS,EAAE,kBAAkB;IAC7B,qDAAqD;IACrD,UAAU,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IACzC,sDAAsD;IACtD,eAAe,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC9C,kCAAkC;IAClC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;CACjC,CAAC,CAAC"}