@sentry/junior-memory 0.78.0 → 0.80.0

package/dist/store.d.ts

@@ -8,6 +8,11 @@ declare const createMemoryInputSchema: z.ZodObject<{
     content: z.ZodString;
     expiresAtMs: z.ZodOptional<z.ZodNumber>;
     idempotencyKey: z.ZodString;
+    kind: z.ZodEnum<{
+        preference: "preference";
+        procedure: "procedure";
+        knowledge: "knowledge";
+    }>;
 }, z.core.$strict>;
 declare const listMemoriesInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -20,6 +25,9 @@ declare const archiveMemoryInputSchema: z.ZodObject<{
     id: z.ZodString;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+declare const archiveExpiredMemoriesInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 declare const memoryRecordSchema: z.ZodObject<{
     archivedAtMs: z.ZodOptional<z.ZodNumber>;
     archiveReason: z.ZodOptional<z.ZodString>;
@@ -39,15 +47,10 @@ declare const memoryRecordSchema: z.ZodObject<{
     }>;
     supersededAtMs: z.ZodOptional<z.ZodNumber>;
     supersededById: z.ZodOptional<z.ZodString>;
-    type: z.ZodEnum<{
+    kind: z.ZodEnum<{
         preference: "preference";
-        identity: "identity";
-        relationship: "relationship";
+        procedure: "procedure";
         knowledge: "knowledge";
-        context: "context";
-        event: "event";
-        task: "task";
-        observation: "observation";
     }>;
 }, z.core.$strict>;
 export type MemoryRecord = z.output<typeof memoryRecordSchema>;
@@ -60,6 +63,10 @@ export interface CreateMemoryResult {
 export type ListMemoriesInput = z.output<typeof listMemoriesInputSchema>;
 export type SearchMemoriesInput = z.output<typeof searchMemoriesInputSchema>;
 export type ArchiveMemoryInput = z.output<typeof archiveMemoryInputSchema>;
+export type ArchiveExpiredMemoriesInput = z.output<typeof archiveExpiredMemoriesInputSchema>;
+export interface ArchiveExpiredMemoriesResult {
+    archivedCount: number;
+}
 export interface MemoryEmbeddingProvider {
     /** Embed normalized memory text for derived vector retrieval. */
     embedTexts(input: {
@@ -77,6 +84,8 @@ export interface MemoryStoreOptions {
 }
 /** Context-bound storage operations for visible long-term memories. */
 export interface MemoryStore {
+    /** Archive expired memories visible in the current runtime context. */
+    archiveExpiredMemories(input?: ArchiveExpiredMemoriesInput): Promise<ArchiveExpiredMemoriesResult>;
     /** Archive a visible memory in the current runtime context. */
     archiveMemory(input: ArchiveMemoryInput): Promise<MemoryRecord>;
     /** Store a personal memory for the current requester. */

package/dist/types.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
-export declare const MEMORY_TYPES: readonly ["preference", "identity", "relationship", "knowledge", "context", "event", "task", "observation"];
+export declare const MEMORY_KINDS: readonly ["preference", "procedure", "knowledge"];
 export declare const MEMORY_SCOPES: readonly ["personal", "conversation"];
 export declare const MEMORY_SUBJECT_TYPES: readonly ["user", "conversation", "general"];
 export declare const MEMORY_SOURCE_PLATFORMS: readonly ["slack", "local"];
 export declare const MEMORY_EMBEDDING_METRICS: readonly ["cosine"];
 export declare const MEMORY_EMBEDDING_DIMENSIONS = 1536;
-export type MemoryType = (typeof MEMORY_TYPES)[number];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
 export type MemoryScope = (typeof MEMORY_SCOPES)[number];
 export type MemorySubjectType = (typeof MEMORY_SUBJECT_TYPES)[number];
 export type MemorySourcePlatform = (typeof MEMORY_SOURCE_PLATFORMS)[number];

package/migrations/0004_gigantic_celestials.sql

@@ -0,0 +1,12 @@
+ALTER TABLE "junior_memory_memories" DROP CONSTRAINT "junior_memory_memories_type_check";--> statement-breakpoint
+UPDATE "junior_memory_memories"
+SET "type" = CASE
+  WHEN "type" = 'task' THEN 'procedure'
+  WHEN "type" IN ('identity', 'relationship', 'context', 'event', 'observation') THEN 'knowledge'
+  ELSE "type"
+END;--> statement-breakpoint
+ALTER TABLE "junior_memory_memories" ADD CONSTRAINT "junior_memory_memories_kind_check" CHECK ("junior_memory_memories"."type" IN (
+        'preference',
+        'procedure',
+        'knowledge'
+      ));

package/migrations/meta/0004_snapshot.json

@@ -0,0 +1,348 @@
+{
+  "id": "e915b537-996a-488c-a828-7cf4da06be44",
+  "prevId": "2f78c37c-9c80-4f92-92f8-7eaa1951862b",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.junior_memory_embeddings": {
+      "name": "junior_memory_embeddings",
+      "schema": "",
+      "columns": {
+        "memory_id": {
+          "name": "memory_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dimensions": {
+          "name": "dimensions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metric": {
+          "name": "metric",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1536)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at_ms": {
+          "name": "created_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "junior_memory_embeddings_model_idx": {
+          "name": "junior_memory_embeddings_model_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "model",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "dimensions",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "metric",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "junior_memory_embeddings_memory_id_junior_memory_memories_id_fk": {
+          "name": "junior_memory_embeddings_memory_id_junior_memory_memories_id_fk",
+          "tableFrom": "junior_memory_embeddings",
+          "tableTo": "junior_memory_memories",
+          "columnsFrom": ["memory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "junior_memory_embeddings_metric_check": {
+          "name": "junior_memory_embeddings_metric_check",
+          "value": "\"junior_memory_embeddings\".\"metric\" IN ('cosine')"
+        },
+        "junior_memory_embeddings_dimensions_check": {
+          "name": "junior_memory_embeddings_dimensions_check",
+          "value": "\"junior_memory_embeddings\".\"dimensions\" = 1536"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.junior_memory_memories": {
+      "name": "junior_memory_memories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_key": {
+          "name": "scope_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_type": {
+          "name": "subject_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_key": {
+          "name": "subject_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_platform": {
+          "name": "source_platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_key": {
+          "name": "source_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "observed_at_ms": {
+          "name": "observed_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at_ms": {
+          "name": "created_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at_ms": {
+          "name": "expires_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at_ms": {
+          "name": "superseded_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_by_id": {
+          "name": "superseded_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at_ms": {
+          "name": "archived_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archive_reason": {
+          "name": "archive_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "junior_memory_memories_visible_idx": {
+          "name": "junior_memory_memories_visible_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at_ms",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_by_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "junior_memory_memories_expiration_idx": {
+          "name": "junior_memory_memories_expiration_idx",
+          "columns": [
+            {
+              "expression": "expires_at_ms",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"expires_at_ms\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "junior_memory_memories_idempotency_idx": {
+          "name": "junior_memory_memories_idempotency_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "idempotency_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"junior_memory_memories\".\"idempotency_key\" IS NOT NULL AND \"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_by_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "junior_memory_memories_scope_check": {
+          "name": "junior_memory_memories_scope_check",
+          "value": "\"junior_memory_memories\".\"scope\" IN ('personal', 'conversation')"
+        },
+        "junior_memory_memories_kind_check": {
+          "name": "junior_memory_memories_kind_check",
+          "value": "\"junior_memory_memories\".\"type\" IN (\n        'preference',\n        'procedure',\n        'knowledge'\n      )"
+        },
+        "junior_memory_memories_subject_type_check": {
+          "name": "junior_memory_memories_subject_type_check",
+          "value": "\"junior_memory_memories\".\"subject_type\" IN ('user', 'conversation', 'general')"
+        },
+        "junior_memory_memories_subject_key_check": {
+          "name": "junior_memory_memories_subject_key_check",
+          "value": "(\"junior_memory_memories\".\"subject_type\" = 'general' AND \"junior_memory_memories\".\"subject_key\" IS NULL) OR (\"junior_memory_memories\".\"subject_type\" IN ('user', 'conversation') AND \"junior_memory_memories\".\"subject_key\" IS NOT NULL AND length(\"junior_memory_memories\".\"subject_key\") > 0)"
+        },
+        "junior_memory_memories_source_platform_check": {
+          "name": "junior_memory_memories_source_platform_check",
+          "value": "\"junior_memory_memories\".\"source_platform\" IN ('slack', 'local')"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/migrations/meta/_journal.json

@@ -29,6 +29,13 @@
       "when": 1782582311997,
       "tag": "0003_public_slack_workspace_memory",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1782676852768,
+      "tag": "0004_gigantic_celestials",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.78.0"
+    "@sentry/junior-plugin-api": "0.80.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/agent.ts

@@ -1,9 +1,8 @@
 import type { PluginModel } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-import { memoryRuntimeContextSchema } from "./types";
+import { MEMORY_KINDS, memoryRuntimeContextSchema } from "./types";
 
-const memoryTargetSchema = z.enum(["requester", "conversation"]);
-const memoryKindSchema = z.enum(["preference", "procedure", "fact"]);
+const memoryKindSchema = z.enum(MEMORY_KINDS);
 const memoryRejectReasonSchema = z.enum([
   "not_public_shareable",
   "secret_or_credential",
@@ -75,7 +74,7 @@ const memoryReviewDecisionSchema = z.discriminatedUnion("decision", [
   z
     .object({
       decision: z.literal("store"),
-      target: memoryTargetSchema,
+      kind: memoryKindSchema,
       content: z.string().min(1),
       expiresAtMs: z.number().finite().optional(),
     })
@@ -92,7 +91,7 @@ const memoryReviewResponseSchema = z.discriminatedUnion("decision", [
     .object({
       decision: z.literal("store"),
       kind: memoryKindSchema.describe(
-        "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use fact for shared project, channel, operational, or runbook knowledge.",
+        "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts.",
       ),
       canonicalFact: z
         .string()
@@ -113,7 +112,7 @@ const memoryReviewResponseSchema = z.discriminatedUnion("decision", [
 const extractedMemorySchema = z
   .object({
     kind: memoryKindSchema.describe(
-      "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use fact for shared project, channel, operational, or runbook knowledge.",
+      "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts.",
     ),
     canonicalFact: z
       .string()
@@ -124,6 +123,13 @@ const extractedMemorySchema = z
     expiresAtMs: expiresAtMsSchema,
   })
   .strict();
+const extractedMemoryResultSchema = z
+  .object({
+    content: z.string().min(1),
+    expiresAtMs: expiresAtMsSchema,
+    kind: memoryKindSchema,
+  })
+  .strict();
 const extractMemoriesResponseSchema = z
   .object({
     memories: z
@@ -138,20 +144,13 @@ const extractMemoriesResponseSchema = z
 type MemoryReviewResponse = z.output<typeof memoryReviewResponseSchema>;
 type ExtractMemoriesResponse = z.output<typeof extractMemoriesResponseSchema>;
 
-export type MemoryTarget = z.output<typeof memoryTargetSchema>;
-type MemoryKind = z.output<typeof memoryKindSchema>;
-
 export type MemoryReview = z.output<typeof memoryReviewDecisionSchema>;
 
 export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;
 export type ExtractSessionRequest = z.output<
   typeof extractSessionRequestSchema
 >;
-export interface ExtractedMemory {
-  content: string;
-  expiresAtMs: number | null;
-  target: MemoryTarget;
-}
+export type ExtractedMemory = z.output<typeof extractedMemoryResultSchema>;
 
 export interface MemoryAgent {
   extractSessionMemories(
@@ -186,13 +185,6 @@ const CANONICAL_CONTENT_RULES = [
   "- Remove requester names, display names, requester/user labels, first- or second-person wording, thread labels, channel labels, and source labels.",
 ];
 
-function targetForKind(kind: MemoryKind): MemoryTarget {
-  if (kind === "preference") {
-    return "requester";
-  }
-  return "conversation";
-}
-
 function escapeXml(value: string): string {
   return value
     .replaceAll("&", "&amp;")
@@ -259,7 +251,7 @@ function memoryKindsContext(): string {
     "<memory-kinds>",
     "- preference: a durable first-person personal preference, opinion, habit, or workflow owned by the current requester. Stored as requester memory.",
     "- procedure: reusable instructions for how a task, lookup, investigation, process, triage flow, or runbook should be done. Store the method, source-of-truth, prerequisite, or decision path when it took effort to discover. Stored as conversation memory.",
-    "- fact: stable shared project, channel, operational, or runbook knowledge that is not a personal requester preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
+    "- knowledge: stable shared project, channel, operational, or runbook fact that is not a personal requester preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
     "</memory-kinds>",
   ].join("\n");
 }
@@ -279,14 +271,14 @@ function reviewPrompt(request: CreateMemoryRequest): string {
     "",
     "<rules>",
     "- Return store only when the candidate is public/shareable, durable, and self-contained.",
-    "- First classify the memory kind: preference, procedure, or fact.",
+    "- First classify the memory kind: preference, procedure, or knowledge.",
     "- Use kind=preference only for first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
     "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
     "- Use kind=procedure for reusable task/process/runbook instructions.",
-    "- Use kind=fact for shared project, channel, operational, or runbook knowledge.",
+    "- Use kind=knowledge for shared project, channel, operational, or runbook facts.",
     "- When current-user-message contains an explicit memory request with a concrete fact or procedure, extract from current-user-message even if the candidate is vague, incomplete, or phrased as an instruction.",
     "- A candidate may be badly phrased by an outer assistant or extraction pass. When current-user-message contains the requester's own first-person memory fact, treat that as requester-authored source evidence and canonicalize the fact instead of rejecting for third-person wording.",
-    "- When candidate wording personalizes a shared task, process, runbook, project, channel, or operational fact, use current-user-message to recover the shared fact and classify it as procedure or fact.",
+    "- When candidate wording personalizes a shared task, process, runbook, project, channel, or operational fact, use current-user-message to recover the shared fact and classify it as procedure or knowledge.",
     "- Explicit procedure requests are valid when the source text contains both task context and action. Canonicalize them as shared procedure facts instead of rejecting them as vague.",
     "- Store content as person-less, source-less canonical knowledge. Ownership and source live in structured metadata, not prose.",
     "- For requester memories, omit the subject and write the content as a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
@@ -349,7 +341,7 @@ function sessionExtractionPrompt(request: ExtractSessionRequest): string {
     "- Do not store the fact that the user asked for advice, search, recall, planning, listing, inspection, or removal. Store only stable knowledge discovered in response, such as a reusable method or source-of-truth.",
     "- A user question asking how, what, where, or whether to do something is not source evidence for the answer. Store the answer only when supported by a user-authored factual statement or a tool result.",
     "- Set kind=procedure for reusable task/process/runbook instructions.",
-    "- Set kind=fact for shared team, project, channel, runbook, or operational knowledge.",
+    "- Set kind=knowledge for shared team, project, channel, runbook, or operational facts.",
     "- Set kind=preference only for clear durable first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
     "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
     "- User-authored task instructions are procedures, not preferences, unless they explicitly describe the requester's personal preference or habit.",
@@ -398,7 +390,7 @@ function memoryReviewFromResponse(
   if (response.decision === "store") {
     return parseMemoryReview({
       decision: "store",
-      target: targetForKind(response.kind),
+      kind: response.kind,
       content: response.canonicalFact,
       ...(response.expiresAtMs !== null
         ? { expiresAtMs: response.expiresAtMs }
@@ -416,14 +408,20 @@ function extractedMemoriesFromResponse(
 ): ExtractedMemory[] {
   const toMemory = (
     memory: z.output<typeof extractedMemorySchema>,
-  ): ExtractedMemory => ({
-    content: memory.canonicalFact,
-    expiresAtMs: memory.expiresAtMs,
-    target: targetForKind(memory.kind),
-  });
+  ): ExtractedMemory =>
+    parseExtractedMemory({
+      content: memory.canonicalFact,
+      expiresAtMs: memory.expiresAtMs,
+      kind: memory.kind,
+    });
   return response.memories.map(toMemory);
 }
 
+/** Parse the canonical extracted-memory shape stored across task retries. */
+export function parseExtractedMemory(memory: unknown): ExtractedMemory {
+  return extractedMemoryResultSchema.parse(memory);
+}
+
 /** Parse the structured decision returned by the memory agent. */
 export function parseMemoryReview(result: unknown): MemoryReview {
   return memoryReviewDecisionSchema.parse(result);

package/src/cli/format.ts

@@ -17,7 +17,7 @@ export function formatMemory(
     `scope_key=${row.scopeKey}`,
     `subject_type=${row.subjectType}`,
     ...(row.subjectKey ? [`subject_key=${row.subjectKey}`] : []),
-    `type=${row.type}`,
+    `kind=${row.kind}`,
     `created_at=${formatDate(row.createdAtMs)}`,
     `observed_at=${formatDate(row.observedAtMs)}`,
     `expires_at=${formatDate(row.expiresAtMs)}`,

package/src/db/schema.ts

@@ -21,7 +21,7 @@ import {
   MEMORY_SCOPES,
   MEMORY_SOURCE_PLATFORMS,
   MEMORY_SUBJECT_TYPES,
-  MEMORY_TYPES,
+  MEMORY_KINDS,
 } from "../types";
 
 export const juniorMemoryMemories = pgTable(
@@ -30,7 +30,7 @@ export const juniorMemoryMemories = pgTable(
     id: text("id").primaryKey(),
     scope: text("scope", { enum: MEMORY_SCOPES }).notNull(),
     scopeKey: text("scope_key").notNull(),
-    type: text("type", { enum: MEMORY_TYPES }).notNull(),
+    kind: text("type", { enum: MEMORY_KINDS }).notNull(),
     subjectType: text("subject_type", { enum: MEMORY_SUBJECT_TYPES }).notNull(),
     subjectKey: text("subject_key"),
     content: text("content").notNull(),
@@ -68,16 +68,11 @@ export const juniorMemoryMemories = pgTable(
       sql`${table.scope} IN ('personal', 'conversation')`,
     ),
     check(
-      "junior_memory_memories_type_check",
-      sql`${table.type} IN (
+      "junior_memory_memories_kind_check",
+      sql`${table.kind} IN (
         'preference',
-        'identity',
-        'relationship',
-        'knowledge',
-        'context',
-        'event',
-        'task',
-        'observation'
+        'procedure',
+        'knowledge'
       )`,
     ),
     check(