@aletheia-labs/core 0.1.0

package/dist/types/action.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Action types for the consumer API: what an agent proposes to DO, and the
+ * context in which it proposes to do it.
+ */
+import { z } from 'zod';
+/**
+ * What an agent wants to do. The verb is the receiver-classified `ACT` class;
+ * `target` and `params` are advisory metadata.
+ */
+export declare const ProposedActionSchema: z.ZodObject<{
+    /** Receiver-side classification — never accept this from the sender. */
+    classifiedAction: z.ZodEnum<["local_documentation", "local_fixture", "local_diagnostic", "local_report", "external_send", "runtime_change", "config_change", "publication", "durable_memory_write", "delete", "canary", "enforcement", "production_action", "l2_plus", "unknown"]>;
+    /** What/where the action operates on. */
+    target: z.ZodString;
+    /** Free-form params (must round-trip JSON cleanly). */
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    classifiedAction: "unknown" | "local_documentation" | "local_fixture" | "local_diagnostic" | "local_report" | "external_send" | "runtime_change" | "config_change" | "publication" | "durable_memory_write" | "delete" | "canary" | "enforcement" | "production_action" | "l2_plus";
+    params?: Record<string, unknown> | undefined;
+}, {
+    target: string;
+    classifiedAction: "unknown" | "local_documentation" | "local_fixture" | "local_diagnostic" | "local_report" | "external_send" | "runtime_change" | "config_change" | "publication" | "durable_memory_write" | "delete" | "canary" | "enforcement" | "production_action" | "l2_plus";
+    params?: Record<string, unknown> | undefined;
+}>;
+export type ProposedAction = z.infer<typeof ProposedActionSchema>;
+/**
+ * Context an agent passes to tryAct(): who is acting, in what scope, with
+ * which memories cited.
+ */
+export declare const ActionContextSchema: z.ZodObject<{
+    agentId: z.ZodBranded<z.ZodString, "AgentId">;
+    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";
+    }>]>;
+    /** Memories the agent is citing as authority for this action. */
+    citedMemoryIds: z.ZodArray<z.ZodBranded<z.ZodString, "MemoryId">, "many">;
+}, "strip", z.ZodTypeAny, {
+    agentId: string & z.BRAND<"AgentId">;
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    citedMemoryIds: (string & z.BRAND<"MemoryId">)[];
+}, {
+    agentId: string;
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    citedMemoryIds: string[];
+}>;
+export type ActionContext = z.infer<typeof ActionContextSchema>;
+/**
+ * RecallQuery — what an agent asks the RetrievalRouter for.
+ *
+ * No semantic similarity field. Recall is by status, scope, type, and an
+ * optional opaque tag — never by embedding distance.
+ */
+export declare const RecallQuerySchema: z.ZodObject<{
+    /** Caller identity, used for visibility filtering. */
+    agentId: z.ZodBranded<z.ZodString, "AgentId">;
+    /** Visibility/scope must permit retrieval. */
+    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";
+    }>]>;
+    /** Restrict to atoms of these statuses (default: ['verified', 'trusted']). */
+    requiredStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<["candidate", "verified", "trusted", "deprecated", "rejected", "sealed", "human_required"]>, "many">>;
+    /** Restrict to these memory types. */
+    memoryTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["observation", "claim", "preference", "policy", "decision", "task_state", "warning", "skill"]>, "many">>;
+    /** Optional opaque topic tag — exact match only, not similarity. */
+    topic: z.ZodOptional<z.ZodString>;
+    /** Max atoms to return. */
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    agentId: string & z.BRAND<"AgentId">;
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    topic?: string | undefined;
+    requiredStatus?: ("candidate" | "verified" | "trusted" | "deprecated" | "rejected" | "sealed" | "human_required")[] | undefined;
+    memoryTypes?: ("observation" | "claim" | "preference" | "policy" | "decision" | "task_state" | "warning" | "skill")[] | undefined;
+    limit?: number | undefined;
+}, {
+    agentId: string;
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    topic?: string | undefined;
+    requiredStatus?: ("candidate" | "verified" | "trusted" | "deprecated" | "rejected" | "sealed" | "human_required")[] | undefined;
+    memoryTypes?: ("observation" | "claim" | "preference" | "policy" | "decision" | "task_state" | "warning" | "skill")[] | undefined;
+    limit?: number | undefined;
+}>;
+export type RecallQuery = z.infer<typeof RecallQuerySchema>;
+//# sourceMappingURL=action.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/types/action.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAC/B,wEAAwE;;IAExE,yCAAyC;;IAEzC,uDAAuD;;;;;;;;;;EAEvD,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;IAC5B,sDAAsD;;IAEtD,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9C,8EAA8E;;IAE9E,sCAAsC;;IAEtC,oEAAoE;;IAEpE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/types/action.js

@@ -0,0 +1,50 @@
+/**
+ * Action types for the consumer API: what an agent proposes to DO, and the
+ * context in which it proposes to do it.
+ */
+import { z } from 'zod';
+import { ActionClassSchema, MemoryStatusSchema, MemoryTypeSchema, ScopeSchema } from './enums.js';
+import { AgentIdSchema, MemoryIdSchema } from './primitives.js';
+/**
+ * What an agent wants to do. The verb is the receiver-classified `ACT` class;
+ * `target` and `params` are advisory metadata.
+ */
+export const ProposedActionSchema = z.object({
+    /** Receiver-side classification — never accept this from the sender. */
+    classifiedAction: ActionClassSchema,
+    /** What/where the action operates on. */
+    target: z.string().min(1).max(512),
+    /** Free-form params (must round-trip JSON cleanly). */
+    params: z.record(z.unknown()).optional(),
+});
+/**
+ * Context an agent passes to tryAct(): who is acting, in what scope, with
+ * which memories cited.
+ */
+export const ActionContextSchema = z.object({
+    agentId: AgentIdSchema,
+    scope: ScopeSchema,
+    /** Memories the agent is citing as authority for this action. */
+    citedMemoryIds: z.array(MemoryIdSchema),
+});
+/**
+ * RecallQuery — what an agent asks the RetrievalRouter for.
+ *
+ * No semantic similarity field. Recall is by status, scope, type, and an
+ * optional opaque tag — never by embedding distance.
+ */
+export const RecallQuerySchema = z.object({
+    /** Caller identity, used for visibility filtering. */
+    agentId: AgentIdSchema,
+    /** Visibility/scope must permit retrieval. */
+    scope: ScopeSchema,
+    /** Restrict to atoms of these statuses (default: ['verified', 'trusted']). */
+    requiredStatus: z.array(MemoryStatusSchema).optional(),
+    /** Restrict to these memory types. */
+    memoryTypes: z.array(MemoryTypeSchema).optional(),
+    /** Optional opaque topic tag — exact match only, not similarity. */
+    topic: z.string().min(1).max(256).optional(),
+    /** Max atoms to return. */
+    limit: z.number().int().positive().max(1000).optional(),
+});
+//# sourceMappingURL=action.js.map

package/dist/types/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","sourceRoot":"","sources":["../../src/types/action.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAClG,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEhE;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,wEAAwE;IACxE,gBAAgB,EAAE,iBAAiB;IACnC,yCAAyC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAClC,uDAAuD;IACvD,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACzC,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,OAAO,EAAE,aAAa;IACtB,KAAK,EAAE,WAAW;IAClB,iEAAiE;IACjE,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;CACxC,CAAC,CAAC;AAGH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,sDAAsD;IACtD,OAAO,EAAE,aAAa;IACtB,8CAA8C;IAC9C,KAAK,EAAE,WAAW;IAClB,8EAA8E;IAC9E,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IACtD,sCAAsC;IACtC,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE;IACjD,oEAAoE;IACpE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IAC5C,2BAA2B;IAC3B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;CACxD,CAAC,CAAC"}

package/dist/types/compressed-receipt.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Compressed Temporal Receipt (specs/compressed-temporal-receipt-v0.md).
+ *
+ * The compact cross-source handoff tuple. 11 required authority fields,
+ * 5 optional audit fields. Every field has a fail-closed interpretation.
+ *
+ * Wire keys (deliberately short, from the spec):
+ *   Required: SRC, SRCPATH, SRCDIGEST, PROD, FRESH, SCOPE, PB, NO, LRE, TOK, ACT
+ *   Optional: CTRID, RB, CHAIN, CONF, PROSE
+ */
+import { z } from 'zod';
+/**
+ * Internal representation of a Compressed Temporal Receipt.
+ *
+ * This is the parsed, validated form. The wire format (SRC=...; PROD=...; ...)
+ * is handled by codec functions in a separate module — never construct one of
+ * these by hand from untrusted input, always go through the parser.
+ */
+export declare const CompressedReceiptSchema: z.ZodObject<{
+    /** SRC — source artifact identity/lane. */
+    src: z.ZodBranded<z.ZodString, "SourceArtifactId">;
+    /** SRCPATH — source path or source lane binding. */
+    srcPath: z.ZodEffects<z.ZodString, string, string>;
+    /** SRCDIGEST — digest of the source artifact's content. */
+    srcDigest: z.ZodString;
+    /** PROD — produced-at timestamp (ISO-8601 UTC). */
+    producedAt: z.ZodString;
+    /** FRESH — receiver freshness assessment. */
+    freshness: z.ZodEnum<["current", "stale", "unknown"]>;
+    /** SCOPE — usable scope kind of the packet. */
+    scope: z.ZodEnum<["local", "project", "user", "team", "global"]>;
+    /** PB — promotion/use boundary. */
+    promotionBoundary: z.ZodEnum<["no_memory_write", "no_durable_promotion", "human_confirmation_required"]>;
+    /**
+     * NO — explicit forbidden effects.
+     *
+     * Spec rule: this is a *prohibition lane*, not a permission lane. The
+     * presence of words like "runtime" or "L2+" inside `NO` means "forbidden",
+     * NOT "granted". The receiver MUST NOT treat these as operational grants.
+     *
+     * Empty array fails closed (missing prohibitions → fetch_abstain).
+     */
+    forbiddenEffects: z.ZodArray<z.ZodEnum<["local_only", "no_runtime_effect", "external_send_requires_human", "config_change_forbidden"]>, "many">;
+    /** LRE — later restrictive event status. Anything except `none` fails closed. */
+    laterRestrictiveEvent: z.ZodEnum<["none", "superseded", "tombstoned", "conflict_unresolved", "unknown"]>;
+    /**
+     * TOK — tuple completeness token. `true` means "all required fields are
+     * present and not truncated". `false` fails closed.
+     */
+    tupleComplete: z.ZodLiteral<true>;
+    /** ACT — proposed action, to be independently classified by the receiver. */
+    proposedAction: z.ZodEnum<["local_documentation", "local_fixture", "local_diagnostic", "local_report", "external_send", "runtime_change", "config_change", "publication", "durable_memory_write", "delete", "canary", "enforcement", "production_action", "l2_plus", "unknown"]>;
+    /** CTRID — receipt identifier (audit only, never authority). */
+    receiptId: z.ZodOptional<z.ZodBranded<z.ZodString, "ReceiptId">>;
+    /** RB — receiver behavior hint (useful, not permission). */
+    receiverHint: z.ZodOptional<z.ZodString>;
+    /** CHAIN — lineage label (useful, not permission). */
+    chain: z.ZodOptional<z.ZodString>;
+    /**
+     * CONF — confidence value [0, 1]. NEVER authority by itself.
+     * Spec: "confidence cannot override weak evidence, stale freshness,
+     * wrong scope, or missing permission."
+     */
+    confidence: z.ZodOptional<z.ZodNumber>;
+    /**
+     * PROSE — human-readable summary. NEVER authority by itself; the receiver
+     * must not infer permission from polished prose.
+     */
+    prose: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    scope: "team" | "local" | "project" | "user" | "global";
+    src: string & z.BRAND<"SourceArtifactId">;
+    srcPath: string;
+    srcDigest: string;
+    producedAt: string;
+    freshness: "unknown" | "current" | "stale";
+    promotionBoundary: "no_memory_write" | "no_durable_promotion" | "human_confirmation_required";
+    forbiddenEffects: ("local_only" | "no_runtime_effect" | "external_send_requires_human" | "config_change_forbidden")[];
+    laterRestrictiveEvent: "unknown" | "none" | "superseded" | "tombstoned" | "conflict_unresolved";
+    tupleComplete: true;
+    proposedAction: "unknown" | "local_documentation" | "local_fixture" | "local_diagnostic" | "local_report" | "external_send" | "runtime_change" | "config_change" | "publication" | "durable_memory_write" | "delete" | "canary" | "enforcement" | "production_action" | "l2_plus";
+    receiptId?: (string & z.BRAND<"ReceiptId">) | undefined;
+    receiverHint?: string | undefined;
+    chain?: string | undefined;
+    confidence?: number | undefined;
+    prose?: string | undefined;
+}, {
+    scope: "team" | "local" | "project" | "user" | "global";
+    src: string;
+    srcPath: string;
+    srcDigest: string;
+    producedAt: string;
+    freshness: "unknown" | "current" | "stale";
+    promotionBoundary: "no_memory_write" | "no_durable_promotion" | "human_confirmation_required";
+    forbiddenEffects: ("local_only" | "no_runtime_effect" | "external_send_requires_human" | "config_change_forbidden")[];
+    laterRestrictiveEvent: "unknown" | "none" | "superseded" | "tombstoned" | "conflict_unresolved";
+    tupleComplete: true;
+    proposedAction: "unknown" | "local_documentation" | "local_fixture" | "local_diagnostic" | "local_report" | "external_send" | "runtime_change" | "config_change" | "publication" | "durable_memory_write" | "delete" | "canary" | "enforcement" | "production_action" | "l2_plus";
+    receiptId?: string | undefined;
+    receiverHint?: string | undefined;
+    chain?: string | undefined;
+    confidence?: number | undefined;
+    prose?: string | undefined;
+}>;
+export type CompressedReceipt = z.infer<typeof CompressedReceiptSchema>;
+/**
+ * The 11 authority-critical wire keys, in spec-defined order.
+ * Used by parsers and by `tupleComplete` checks.
+ */
+export declare const AUTHORITY_CRITICAL_KEYS: readonly ["SRC", "SRCPATH", "SRCDIGEST", "PROD", "FRESH", "SCOPE", "PB", "NO", "LRE", "TOK", "ACT"];
+export type AuthorityCriticalKey = (typeof AUTHORITY_CRITICAL_KEYS)[number];
+/**
+ * The 5 optional audit keys.
+ */
+export declare const OPTIONAL_AUDIT_KEYS: readonly ["CTRID", "RB", "CHAIN", "CONF", "PROSE"];
+export type OptionalAuditKey = (typeof OPTIONAL_AUDIT_KEYS)[number];
+//# sourceMappingURL=compressed-receipt.d.ts.map

package/dist/types/compressed-receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressed-receipt.d.ts","sourceRoot":"","sources":["../../src/types/compressed-receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;IAElC,2CAA2C;;IAE3C,oDAAoD;;IAEpD,2DAA2D;;IAE3D,mDAAmD;;IAEnD,6CAA6C;;IAE7C,+CAA+C;;IAE/C,mCAAmC;;IAEnC;;;;;;;;OAQG;;IAIH,iFAAiF;;IAEjF;;;OAGG;;IAIH,6EAA6E;;IAI7E,gEAAgE;;IAEhE,4DAA4D;;IAE5D,sDAAsD;;IAEtD;;;;OAIG;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,uBAAuB,qGAY1B,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,mBAAmB,oDAAqD,CAAC;AACtF,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/types/compressed-receipt.js

@@ -0,0 +1,100 @@
+/**
+ * Compressed Temporal Receipt (specs/compressed-temporal-receipt-v0.md).
+ *
+ * The compact cross-source handoff tuple. 11 required authority fields,
+ * 5 optional audit fields. Every field has a fail-closed interpretation.
+ *
+ * Wire keys (deliberately short, from the spec):
+ *   Required: SRC, SRCPATH, SRCDIGEST, PROD, FRESH, SCOPE, PB, NO, LRE, TOK, ACT
+ *   Optional: CTRID, RB, CHAIN, CONF, PROSE
+ */
+import { z } from 'zod';
+import { ActionClassSchema, EffectBoundarySchema, FreshnessSchema, LaterRestrictiveEventSchema, PromotionBoundarySchema, ScopeKindSchema, } from './enums.js';
+import { HashDigestSchema, IsoTimestampSchema, ReceiptIdSchema, SourceArtifactIdSchema, SourcePathSchema, } from './primitives.js';
+/**
+ * Internal representation of a Compressed Temporal Receipt.
+ *
+ * This is the parsed, validated form. The wire format (SRC=...; PROD=...; ...)
+ * is handled by codec functions in a separate module — never construct one of
+ * these by hand from untrusted input, always go through the parser.
+ */
+export const CompressedReceiptSchema = z.object({
+    // -- Required authority-critical fields -----------------------------------
+    /** SRC — source artifact identity/lane. */
+    src: SourceArtifactIdSchema,
+    /** SRCPATH — source path or source lane binding. */
+    srcPath: SourcePathSchema,
+    /** SRCDIGEST — digest of the source artifact's content. */
+    srcDigest: HashDigestSchema,
+    /** PROD — produced-at timestamp (ISO-8601 UTC). */
+    producedAt: IsoTimestampSchema,
+    /** FRESH — receiver freshness assessment. */
+    freshness: FreshnessSchema,
+    /** SCOPE — usable scope kind of the packet. */
+    scope: ScopeKindSchema,
+    /** PB — promotion/use boundary. */
+    promotionBoundary: PromotionBoundarySchema,
+    /**
+     * NO — explicit forbidden effects.
+     *
+     * Spec rule: this is a *prohibition lane*, not a permission lane. The
+     * presence of words like "runtime" or "L2+" inside `NO` means "forbidden",
+     * NOT "granted". The receiver MUST NOT treat these as operational grants.
+     *
+     * Empty array fails closed (missing prohibitions → fetch_abstain).
+     */
+    forbiddenEffects: z.array(EffectBoundarySchema).min(1, {
+        message: 'NO must list at least one forbidden effect — empty fails closed',
+    }),
+    /** LRE — later restrictive event status. Anything except `none` fails closed. */
+    laterRestrictiveEvent: LaterRestrictiveEventSchema,
+    /**
+     * TOK — tuple completeness token. `true` means "all required fields are
+     * present and not truncated". `false` fails closed.
+     */
+    tupleComplete: z.literal(true, {
+        errorMap: () => ({ message: 'TOK must be true; incomplete tuples fail closed' }),
+    }),
+    /** ACT — proposed action, to be independently classified by the receiver. */
+    proposedAction: ActionClassSchema,
+    // -- Optional audit/readability fields ------------------------------------
+    /** CTRID — receipt identifier (audit only, never authority). */
+    receiptId: ReceiptIdSchema.optional(),
+    /** RB — receiver behavior hint (useful, not permission). */
+    receiverHint: z.string().max(512).optional(),
+    /** CHAIN — lineage label (useful, not permission). */
+    chain: z.string().max(512).optional(),
+    /**
+     * CONF — confidence value [0, 1]. NEVER authority by itself.
+     * Spec: "confidence cannot override weak evidence, stale freshness,
+     * wrong scope, or missing permission."
+     */
+    confidence: z.number().min(0).max(1).optional(),
+    /**
+     * PROSE — human-readable summary. NEVER authority by itself; the receiver
+     * must not infer permission from polished prose.
+     */
+    prose: z.string().max(8192).optional(),
+});
+/**
+ * The 11 authority-critical wire keys, in spec-defined order.
+ * Used by parsers and by `tupleComplete` checks.
+ */
+export const AUTHORITY_CRITICAL_KEYS = [
+    'SRC',
+    'SRCPATH',
+    'SRCDIGEST',
+    'PROD',
+    'FRESH',
+    'SCOPE',
+    'PB',
+    'NO',
+    'LRE',
+    'TOK',
+    'ACT',
+];
+/**
+ * The 5 optional audit keys.
+ */
+export const OPTIONAL_AUDIT_KEYS = ['CTRID', 'RB', 'CHAIN', 'CONF', 'PROSE'];
+//# sourceMappingURL=compressed-receipt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compressed-receipt.js","sourceRoot":"","sources":["../../src/types/compressed-receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,2BAA2B,EAC3B,uBAAuB,EACvB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,4EAA4E;IAC5E,2CAA2C;IAC3C,GAAG,EAAE,sBAAsB;IAC3B,oDAAoD;IACpD,OAAO,EAAE,gBAAgB;IACzB,2DAA2D;IAC3D,SAAS,EAAE,gBAAgB;IAC3B,mDAAmD;IACnD,UAAU,EAAE,kBAAkB;IAC9B,6CAA6C;IAC7C,SAAS,EAAE,eAAe;IAC1B,+CAA+C;IAC/C,KAAK,EAAE,eAAe;IACtB,mCAAmC;IACnC,iBAAiB,EAAE,uBAAuB;IAC1C;;;;;;;;OAQG;IACH,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE;QACrD,OAAO,EAAE,iEAAiE;KAC3E,CAAC;IACF,iFAAiF;IACjF,qBAAqB,EAAE,2BAA2B;IAClD;;;OAGG;IACH,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE;QAC7B,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,iDAAiD,EAAE,CAAC;KACjF,CAAC;IACF,6EAA6E;IAC7E,cAAc,EAAE,iBAAiB;IAEjC,4EAA4E;IAC5E,gEAAgE;IAChE,SAAS,EAAE,eAAe,CAAC,QAAQ,EAAE;IACrC,4DAA4D;IAC5D,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IAC5C,sDAAsD;IACtD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IACrC;;;;OAIG;IACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC/C;;;OAGG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;CACvC,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,KAAK;IACL,SAAS;IACT,WAAW;IACX,MAAM;IACN,OAAO;IACP,OAAO;IACP,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,KAAK;IACL,KAAK;CACG,CAAC;AAGX;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC"}

package/dist/types/conflict.d.ts

@@ -0,0 +1,159 @@
+/**
+ * ConflictRecord — first-class contradictions.
+ * Source: specs/aletheia-memory-authority-v0.md §6 "Conflict Registry".
+ *
+ * Rule: contradictions are NEVER overwritten by summaries. They remain
+ * queryable until explicitly resolved (or superseded by a later restrictive
+ * event).
+ */
+import { z } from 'zod';
+export declare const ConflictStatusSchema: z.ZodEnum<["unresolved", "resolved", "superseded", "requires_human"]>;
+export type ConflictStatus = z.infer<typeof ConflictStatusSchema>;
+export declare const ConflictDecisionPolicySchema: z.ZodEnum<["surface_conflict", "prefer_latest_authoritative", "ask_human", "abstain"]>;
+export type ConflictDecisionPolicy = z.infer<typeof ConflictDecisionPolicySchema>;
+/**
+ * One side of a conflict: which memory makes what claim, with what authority.
+ */
+export declare const ConflictClaimSchema: z.ZodObject<{
+    memoryId: z.ZodBranded<z.ZodString, "MemoryId">;
+    /** The value the claim asserts (string serialization of any type). */
+    value: z.ZodString;
+    /** Authority score of this claim at the time the conflict was recorded. */
+    authority: z.ZodNumber;
+    freshness: z.ZodEnum<["current", "stale", "unknown"]>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    freshness: "unknown" | "current" | "stale";
+    authority: number;
+    memoryId: string & z.BRAND<"MemoryId">;
+}, {
+    value: string;
+    freshness: "unknown" | "current" | "stale";
+    authority: number;
+    memoryId: string;
+}>;
+export type ConflictClaim = z.infer<typeof ConflictClaimSchema>;
+export declare const ConflictRecordSchema: z.ZodObject<{
+    conflictId: z.ZodBranded<z.ZodString, "ConflictId">;
+    /** Topic of the conflict — what the claims disagree about. */
+    topic: z.ZodString;
+    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";
+    }>]>;
+    /** All claims in conflict (typically 2, sometimes more). */
+    claims: z.ZodArray<z.ZodObject<{
+        memoryId: z.ZodBranded<z.ZodString, "MemoryId">;
+        /** The value the claim asserts (string serialization of any type). */
+        value: z.ZodString;
+        /** Authority score of this claim at the time the conflict was recorded. */
+        authority: z.ZodNumber;
+        freshness: z.ZodEnum<["current", "stale", "unknown"]>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        freshness: "unknown" | "current" | "stale";
+        authority: number;
+        memoryId: string & z.BRAND<"MemoryId">;
+    }, {
+        value: string;
+        freshness: "unknown" | "current" | "stale";
+        authority: number;
+        memoryId: string;
+    }>, "many">;
+    status: z.ZodEnum<["unresolved", "resolved", "superseded", "requires_human"]>;
+    decisionPolicy: z.ZodEnum<["surface_conflict", "prefer_latest_authoritative", "ask_human", "abstain"]>;
+    recordedAt: z.ZodString;
+    resolvedAt: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "requires_human" | "superseded" | "unresolved" | "resolved";
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    conflictId: string & z.BRAND<"ConflictId">;
+    topic: string;
+    claims: {
+        value: string;
+        freshness: "unknown" | "current" | "stale";
+        authority: number;
+        memoryId: string & z.BRAND<"MemoryId">;
+    }[];
+    decisionPolicy: "surface_conflict" | "prefer_latest_authoritative" | "ask_human" | "abstain";
+    recordedAt: string;
+    resolvedAt: string | null;
+}, {
+    status: "requires_human" | "superseded" | "unresolved" | "resolved";
+    scope: {
+        kind: "local";
+    } | {
+        kind: "project";
+        projectId: string;
+    } | {
+        kind: "user";
+        userId: string;
+    } | {
+        kind: "team";
+        teamId: string;
+    } | {
+        kind: "global";
+    };
+    conflictId: string;
+    topic: string;
+    claims: {
+        value: string;
+        freshness: "unknown" | "current" | "stale";
+        authority: number;
+        memoryId: string;
+    }[];
+    decisionPolicy: "surface_conflict" | "prefer_latest_authoritative" | "ask_human" | "abstain";
+    recordedAt: string;
+    resolvedAt: string | null;
+}>;
+export type ConflictRecord = z.infer<typeof ConflictRecordSchema>;
+//# sourceMappingURL=conflict.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conflict.d.ts","sourceRoot":"","sources":["../../src/types/conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oBAAoB,uEAK/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,4BAA4B,wFAKvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;IAE9B,sEAAsE;;IAEtE,2EAA2E;;;;;;;;;;;;;EAG3E,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,oBAAoB;;IAE/B,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9D,4DAA4D;;;QAb5D,sEAAsE;;QAEtE,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB3E,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}