syncpoint-ai 0.1.0

package/dist/context/project-memory.d.ts

@@ -0,0 +1,568 @@
+/**
+ * Project Memory Layer — types for long-lived project knowledge.
+ *
+ * Three-tier memory model:
+ *   1. Shared State   — task / checkpoint / handoff / contract / context_snapshot
+ *   2. Project Memory — architecture, decisions, conventions, gotchas, file map
+ *   3. Pinned Memory  — few mandatory rules injected into every context
+ */
+import { z } from "zod";
+export declare enum ProjectMemoryScope {
+    PROJECT = "project",
+    DOMAIN = "domain",
+    TASK = "task",
+    FILE = "file"
+}
+export declare enum ProjectMemoryCategory {
+    OVERVIEW = "overview",
+    ARCHITECTURE = "architecture",
+    DECISION = "decision",
+    CONVENTION = "convention",
+    RISK = "risk",
+    GOTCHA = "gotcha",
+    GLOSSARY = "glossary",
+    FILE_MAP = "file-map",
+    INTEGRATION = "integration"
+}
+export declare enum ProjectMemoryStatus {
+    DRAFT = "draft",
+    APPROVED = "approved",
+    DEPRECATED = "deprecated"
+}
+export declare enum ProjectMemoryConfidence {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high"
+}
+export declare enum ProjectMemorySourceType {
+    HUMAN = "human",
+    AGENT = "agent",
+    CHECKPOINT = "checkpoint",
+    HANDOFF = "handoff",
+    DOC = "doc"
+}
+export declare enum MemoryKind {
+    FACT = "fact",
+    SOFT_CONVENTION = "soft_convention",
+    RISK = "risk",
+    DO_NOT_TOUCH = "do_not_touch",
+    HARD_CONSTRAINT = "hard_constraint",
+    PROTOCOL_RULE = "protocol_rule"
+}
+export declare enum ProjectionTarget {
+    CONTEXT_SNAPSHOT = "context_snapshot",
+    PROTOCOL_GATE = "protocol_gate",
+    CONSTRAINT_RUNTIME = "constraint_runtime"
+}
+export declare enum MemorySeverity {
+    INFO = "info",
+    WARNING = "warning",
+    BLOCKING = "blocking"
+}
+export declare enum ValidityStatus {
+    FRESH = "fresh",
+    NEEDS_REVALIDATION = "needs_revalidation",
+    STALE = "stale",
+    INVALID = "invalid"
+}
+export declare const AppliesToSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+export type AppliesTo = z.infer<typeof AppliesToSchema>;
+export declare const ValiditySchema: z.ZodObject<{
+    status: z.ZodDefault<z.ZodNativeEnum<typeof ValidityStatus>>;
+    staleReason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: ValidityStatus;
+    staleReason?: string | undefined;
+}, {
+    status?: ValidityStatus | undefined;
+    staleReason?: string | undefined;
+}>;
+export type Validity = z.infer<typeof ValiditySchema>;
+export declare const ProjectMemoryValidatorConfigSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    message: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    message: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, z.ZodUnknown, "strip">>;
+export type ProjectMemoryValidatorConfig = z.infer<typeof ProjectMemoryValidatorConfigSchema>;
+/**
+ * Default kind inference from category when kind is not explicitly set.
+ */
+export declare function defaultKindFromCategory(category: string): MemoryKind;
+/**
+ * Valid projection targets for a given memory kind.
+ * hard_constraint and protocol_rule MUST NOT project to context_snapshot only.
+ */
+export declare function validProjectionTargets(kind: MemoryKind): ProjectionTarget[];
+/**
+ * Check if a projection target is valid for a memory kind.
+ */
+export declare function isValidProjection(kind: MemoryKind, target: ProjectionTarget): boolean;
+/**
+ * Compute a content fingerprint for dedup detection.
+ * Normalizes: lowercase, collapse whitespace, strip leading/trailing.
+ * Hash input: `category|normalized_title|normalized_content`
+ */
+export declare function computeMemoryFingerprint(category: string, title: string, content: string): string;
+/**
+ * Check if two memories are content-duplicates (same fingerprint).
+ */
+export declare function isMemoryDuplicate(a: {
+    category: string;
+    title: string;
+    content: string;
+}, b: {
+    category: string;
+    title: string;
+    content: string;
+}): boolean;
+/**
+ * Canonical ProjectMemory schema — flat schema with both V1 and V2 fields.
+ * V2 fields have sensible defaults for backward compatibility with V1 records.
+ *
+ * Schema versioning:
+ *   - schemaVersion 1: V2 fields are present but at defaults (legacy records)
+ *   - schemaVersion 2: V2 fields carry meaningful values (new records)
+ *
+ * The `schemaVersion` discriminant field enables type narrowing via isV1()/isV2().
+ * For strict V1/V2 validation, use ProjectMemoryV1Schema / ProjectMemoryV2Schema.
+ */
+export declare const ProjectMemorySchema: z.ZodObject<{
+    id: z.ZodString;
+    scope: z.ZodNativeEnum<typeof ProjectMemoryScope>;
+    category: z.ZodNativeEnum<typeof ProjectMemoryCategory>;
+    title: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceType: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemorySourceType>>;
+    sourceRef: z.ZodDefault<z.ZodString>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryStatus>>;
+    confidence: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryConfidence>>;
+    taskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fingerprint: z.ZodDefault<z.ZodString>;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    kind: z.ZodDefault<z.ZodNativeEnum<typeof MemoryKind>>;
+    projectionTarget: z.ZodDefault<z.ZodNullable<z.ZodNativeEnum<typeof ProjectionTarget>>>;
+    appliesTo: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    severity: z.ZodDefault<z.ZodNativeEnum<typeof MemorySeverity>>;
+    validityStatus: z.ZodDefault<z.ZodNativeEnum<typeof ValidityStatus>>;
+    validityStaleReason: z.ZodDefault<z.ZodString>;
+    validatorType: z.ZodDefault<z.ZodString>;
+    validatorConfig: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">>>>;
+    createdBy: z.ZodDefault<z.ZodString>;
+    updatedBy: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: ProjectMemoryStatus;
+    id: string;
+    scope: ProjectMemoryScope;
+    taskId: string | null;
+    createdAt: string;
+    kind: MemoryKind;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    tags: string[];
+    sourceType: ProjectMemorySourceType;
+    sourceRef: string;
+    confidence: ProjectMemoryConfidence;
+    fingerprint: string;
+    supersedes: string | null;
+    supersededBy: string | null;
+    schemaVersion: number;
+    projectionTarget: ProjectionTarget | null;
+    appliesTo: Record<string, string[]>;
+    severity: MemorySeverity;
+    validityStatus: ValidityStatus;
+    validityStaleReason: string;
+    validatorType: string;
+    validatorConfig: z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null;
+    createdBy: string;
+    updatedBy: string;
+}, {
+    id: string;
+    scope: ProjectMemoryScope;
+    createdAt: string;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    status?: ProjectMemoryStatus | undefined;
+    taskId?: string | null | undefined;
+    kind?: MemoryKind | undefined;
+    tags?: string[] | undefined;
+    sourceType?: ProjectMemorySourceType | undefined;
+    sourceRef?: string | undefined;
+    confidence?: ProjectMemoryConfidence | undefined;
+    fingerprint?: string | undefined;
+    supersedes?: string | null | undefined;
+    supersededBy?: string | null | undefined;
+    schemaVersion?: number | undefined;
+    projectionTarget?: ProjectionTarget | null | undefined;
+    appliesTo?: Record<string, string[]> | undefined;
+    severity?: MemorySeverity | undefined;
+    validityStatus?: ValidityStatus | undefined;
+    validityStaleReason?: string | undefined;
+    validatorType?: string | undefined;
+    validatorConfig?: z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+}>;
+export type ProjectMemory = z.infer<typeof ProjectMemorySchema>;
+/**
+ * V1 narrowed type — legacy ProjectMemory with schemaVersion 1.
+ * V2 fields are at their defaults (not explicitly set).
+ */
+export interface ProjectMemoryV1 extends ProjectMemory {
+    schemaVersion: 1;
+    kind: MemoryKind.FACT;
+    severity: MemorySeverity.INFO;
+    validityStatus: ValidityStatus.FRESH;
+}
+/**
+ * V2 narrowed type — ProjectMemory with explicit V2 classification.
+ * schemaVersion is 2 and V2 required fields carry meaningful values.
+ */
+export interface ProjectMemoryV2 extends ProjectMemory {
+    schemaVersion: 2;
+    kind: MemoryKind;
+    severity: MemorySeverity;
+    validityStatus: ValidityStatus;
+}
+/** V1-specific schema — schemaVersion locked to 1, V2 fields at defaults. */
+export declare const ProjectMemoryV1Schema: z.ZodObject<{
+    id: z.ZodString;
+    scope: z.ZodNativeEnum<typeof ProjectMemoryScope>;
+    category: z.ZodNativeEnum<typeof ProjectMemoryCategory>;
+    title: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceType: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemorySourceType>>;
+    sourceRef: z.ZodDefault<z.ZodString>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryStatus>>;
+    confidence: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryConfidence>>;
+    taskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fingerprint: z.ZodDefault<z.ZodString>;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodDefault<z.ZodNativeEnum<typeof MemoryKind>>;
+    projectionTarget: z.ZodDefault<z.ZodNullable<z.ZodNativeEnum<typeof ProjectionTarget>>>;
+    appliesTo: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    severity: z.ZodDefault<z.ZodNativeEnum<typeof MemorySeverity>>;
+    validityStatus: z.ZodDefault<z.ZodNativeEnum<typeof ValidityStatus>>;
+    validityStaleReason: z.ZodDefault<z.ZodString>;
+    validatorType: z.ZodDefault<z.ZodString>;
+    validatorConfig: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">>>>;
+    createdBy: z.ZodDefault<z.ZodString>;
+    updatedBy: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+} & {
+    schemaVersion: z.ZodLiteral<1>;
+}, "strip", z.ZodTypeAny, {
+    status: ProjectMemoryStatus;
+    id: string;
+    scope: ProjectMemoryScope;
+    taskId: string | null;
+    createdAt: string;
+    kind: MemoryKind;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    tags: string[];
+    sourceType: ProjectMemorySourceType;
+    sourceRef: string;
+    confidence: ProjectMemoryConfidence;
+    fingerprint: string;
+    supersedes: string | null;
+    supersededBy: string | null;
+    schemaVersion: 1;
+    projectionTarget: ProjectionTarget | null;
+    appliesTo: Record<string, string[]>;
+    severity: MemorySeverity;
+    validityStatus: ValidityStatus;
+    validityStaleReason: string;
+    validatorType: string;
+    validatorConfig: z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null;
+    createdBy: string;
+    updatedBy: string;
+}, {
+    id: string;
+    scope: ProjectMemoryScope;
+    createdAt: string;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    schemaVersion: 1;
+    status?: ProjectMemoryStatus | undefined;
+    taskId?: string | null | undefined;
+    kind?: MemoryKind | undefined;
+    tags?: string[] | undefined;
+    sourceType?: ProjectMemorySourceType | undefined;
+    sourceRef?: string | undefined;
+    confidence?: ProjectMemoryConfidence | undefined;
+    fingerprint?: string | undefined;
+    supersedes?: string | null | undefined;
+    supersededBy?: string | null | undefined;
+    projectionTarget?: ProjectionTarget | null | undefined;
+    appliesTo?: Record<string, string[]> | undefined;
+    severity?: MemorySeverity | undefined;
+    validityStatus?: ValidityStatus | undefined;
+    validityStaleReason?: string | undefined;
+    validatorType?: string | undefined;
+    validatorConfig?: z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+}>;
+/** V2-specific schema — schemaVersion locked to 2, V2 fields required. */
+export declare const ProjectMemoryV2Schema: z.ZodObject<{
+    id: z.ZodString;
+    scope: z.ZodNativeEnum<typeof ProjectMemoryScope>;
+    category: z.ZodNativeEnum<typeof ProjectMemoryCategory>;
+    title: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceType: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemorySourceType>>;
+    sourceRef: z.ZodDefault<z.ZodString>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryStatus>>;
+    confidence: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryConfidence>>;
+    taskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fingerprint: z.ZodDefault<z.ZodString>;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    projectionTarget: z.ZodDefault<z.ZodNullable<z.ZodNativeEnum<typeof ProjectionTarget>>>;
+    appliesTo: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    validityStaleReason: z.ZodDefault<z.ZodString>;
+    validatorType: z.ZodDefault<z.ZodString>;
+    validatorConfig: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">>>>;
+    createdBy: z.ZodDefault<z.ZodString>;
+    updatedBy: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+} & {
+    schemaVersion: z.ZodLiteral<2>;
+    kind: z.ZodNativeEnum<typeof MemoryKind>;
+    severity: z.ZodNativeEnum<typeof MemorySeverity>;
+    validityStatus: z.ZodNativeEnum<typeof ValidityStatus>;
+}, "strip", z.ZodTypeAny, {
+    status: ProjectMemoryStatus;
+    id: string;
+    scope: ProjectMemoryScope;
+    taskId: string | null;
+    createdAt: string;
+    kind: MemoryKind;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    tags: string[];
+    sourceType: ProjectMemorySourceType;
+    sourceRef: string;
+    confidence: ProjectMemoryConfidence;
+    fingerprint: string;
+    supersedes: string | null;
+    supersededBy: string | null;
+    schemaVersion: 2;
+    projectionTarget: ProjectionTarget | null;
+    appliesTo: Record<string, string[]>;
+    severity: MemorySeverity;
+    validityStatus: ValidityStatus;
+    validityStaleReason: string;
+    validatorType: string;
+    validatorConfig: z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null;
+    createdBy: string;
+    updatedBy: string;
+}, {
+    id: string;
+    scope: ProjectMemoryScope;
+    createdAt: string;
+    kind: MemoryKind;
+    updatedAt: string;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    schemaVersion: 2;
+    severity: MemorySeverity;
+    validityStatus: ValidityStatus;
+    status?: ProjectMemoryStatus | undefined;
+    taskId?: string | null | undefined;
+    tags?: string[] | undefined;
+    sourceType?: ProjectMemorySourceType | undefined;
+    sourceRef?: string | undefined;
+    confidence?: ProjectMemoryConfidence | undefined;
+    fingerprint?: string | undefined;
+    supersedes?: string | null | undefined;
+    supersededBy?: string | null | undefined;
+    projectionTarget?: ProjectionTarget | null | undefined;
+    appliesTo?: Record<string, string[]> | undefined;
+    validityStaleReason?: string | undefined;
+    validatorType?: string | undefined;
+    validatorConfig?: z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+}>;
+export declare const ProjectMemoryCreateSchema: z.ZodObject<{
+    scope: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryScope>>;
+    category: z.ZodNativeEnum<typeof ProjectMemoryCategory>;
+    title: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceType: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemorySourceType>>;
+    sourceRef: z.ZodDefault<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNativeEnum<typeof ProjectMemoryConfidence>>;
+    taskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    createdBy: z.ZodDefault<z.ZodString>;
+    kind: z.ZodOptional<z.ZodNativeEnum<typeof MemoryKind>>;
+    projectionTarget: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof ProjectionTarget>>>;
+    appliesTo: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    severity: z.ZodOptional<z.ZodNativeEnum<typeof MemorySeverity>>;
+    validity: z.ZodOptional<z.ZodObject<{
+        status: z.ZodDefault<z.ZodNativeEnum<typeof ValidityStatus>>;
+        staleReason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: ValidityStatus;
+        staleReason?: string | undefined;
+    }, {
+        status?: ValidityStatus | undefined;
+        staleReason?: string | undefined;
+    }>>;
+    validatorType: z.ZodOptional<z.ZodString>;
+    validatorConfig: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip">>>>;
+}, "strip", z.ZodTypeAny, {
+    scope: ProjectMemoryScope;
+    taskId: string | null;
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    tags: string[];
+    sourceType: ProjectMemorySourceType;
+    sourceRef: string;
+    confidence: ProjectMemoryConfidence;
+    createdBy: string;
+    kind?: MemoryKind | undefined;
+    projectionTarget?: ProjectionTarget | null | undefined;
+    appliesTo?: Record<string, string[]> | undefined;
+    severity?: MemorySeverity | undefined;
+    validatorType?: string | undefined;
+    validatorConfig?: z.objectOutputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+    validity?: {
+        status: ValidityStatus;
+        staleReason?: string | undefined;
+    } | undefined;
+}, {
+    title: string;
+    content: string;
+    category: ProjectMemoryCategory;
+    scope?: ProjectMemoryScope | undefined;
+    taskId?: string | null | undefined;
+    kind?: MemoryKind | undefined;
+    tags?: string[] | undefined;
+    sourceType?: ProjectMemorySourceType | undefined;
+    sourceRef?: string | undefined;
+    confidence?: ProjectMemoryConfidence | undefined;
+    projectionTarget?: ProjectionTarget | null | undefined;
+    appliesTo?: Record<string, string[]> | undefined;
+    severity?: MemorySeverity | undefined;
+    validatorType?: string | undefined;
+    validatorConfig?: z.objectInputType<{
+        message: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+    createdBy?: string | undefined;
+    validity?: {
+        status?: ValidityStatus | undefined;
+        staleReason?: string | undefined;
+    } | undefined;
+}>;
+export type ProjectMemoryCreate = z.infer<typeof ProjectMemoryCreateSchema>;
+/**
+ * Upgrade a V1 memory to V2 format.
+ * Infers V2 fields from existing V1 data where possible,
+ * applies sensible defaults where inference isn't possible.
+ */
+export declare function upgradeV1ToV2(memory: ProjectMemoryV1): ProjectMemoryV2;
+/**
+ * Check if a memory is V2 (has explicit V2 classification fields).
+ * Heuristic: V2 memories have a non-default kind OR explicit severity.
+ */
+export declare function isV2(memory: ProjectMemory): memory is ProjectMemoryV2;
+/**
+ * Check if a memory is V1 (legacy, no explicit V2 classification).
+ */
+export declare function isV1(memory: ProjectMemory): memory is ProjectMemoryV1;
+export interface MemoryDedupResult {
+    /** Is this a duplicate of an existing memory? */
+    isDuplicate: boolean;
+    /** ID of the existing duplicate (if found) */
+    existingId?: string;
+    /** Computed fingerprint */
+    fingerprint: string;
+}
+//# sourceMappingURL=project-memory.d.ts.map

package/dist/context/project-memory.d.ts.map

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