memorix 1.2.10 → 1.3.0

package/src/memory/owner.ts

@@ -0,0 +1,75 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const ID_PATTERN = /^[A-Za-z0-9:_-]{3,160}$/;
+
+export interface LocalMemoryOwner {
+  id: string;
+  source: 'environment' | 'local-file';
+}
+
+interface OwnerFile {
+  version: 1;
+  id: string;
+  createdAt: string;
+}
+
+function ownerPath(dataDir: string): string {
+  const resolved = path.resolve(dataDir);
+  // The normal runtime data directory is ~/.memorix/data, so keep identity
+  // beside it. Custom data directories and isolated tests own their identity
+  // inside the supplied directory instead of accidentally sharing a temp root.
+  const home = path.basename(resolved).toLocaleLowerCase('en-US') === 'data'
+    ? path.dirname(resolved)
+    : resolved;
+  return path.join(home, 'memorix-user.json');
+}
+
+function normalizedOwnerId(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed && ID_PATTERN.test(trimmed) ? trimmed : undefined;
+}
+
+async function readOwnerFile(filePath: string): Promise<LocalMemoryOwner | undefined> {
+  try {
+    const value = JSON.parse(await fs.readFile(filePath, 'utf8')) as Partial<OwnerFile>;
+    const id = typeof value.id === 'string' ? normalizedOwnerId(value.id) : undefined;
+    return id ? { id, source: 'local-file' } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Resolve a local stable user identity without deriving anything from prompts,
+ * host names, or account details. Reads do not create an identity; first write
+ * creates one atomically enough for normal local CLI/MCP use.
+ */
+export async function resolveLocalMemoryOwner(
+  dataDir: string,
+  options: { create?: boolean } = {},
+): Promise<LocalMemoryOwner | undefined> {
+  const configured = normalizedOwnerId(process.env.MEMORIX_USER_ID);
+  if (configured) return { id: configured, source: 'environment' };
+
+  const filePath = ownerPath(dataDir);
+  const existing = await readOwnerFile(filePath);
+  if (existing || !options.create) return existing;
+
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const created: OwnerFile = {
+    version: 1,
+    id: 'local-' + randomUUID(),
+    createdAt: new Date().toISOString(),
+  };
+  try {
+    await fs.writeFile(filePath, JSON.stringify(created, null, 2) + '\n', { encoding: 'utf8', flag: 'wx' });
+    return { id: created.id, source: 'local-file' };
+  } catch (error: any) {
+    if (error?.code !== 'EEXIST') throw error;
+    const concurrent = await readOwnerFile(filePath);
+    if (concurrent) return concurrent;
+    throw new Error('Memorix could not establish a valid local memory owner identity.');
+  }
+}

package/src/server.ts

@@ -671,9 +671,10 @@ export async function createMemorixServer(
         'Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), ' +
         'problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), ' +
         'discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), ' +
-        'session-request ([SESSION] original goal). ' +
-        'Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity. ' +
-        'For a read-only task, do not store unless the user explicitly asks to save a record.',
+         'session-request ([SESSION] original goal). ' +
+         'Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity. ' +
+         'Set longTerm only when the caller explicitly wants an additional source-backed long-term candidate; it is never injected until an operator records a review through the CLI. ' +
+         'For a read-only task, do not store unless the user explicitly asks to save a record.',
       inputSchema: {
         entityName: z.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: z.enum(OBSERVATION_TYPES).describe('Observation type for classification'),
@@ -697,30 +698,53 @@ export async function createMemorixServer(
         visibility: z.enum(['personal', 'project', 'team']).optional().describe(
           'Retrieval scope. Project is the normal shared default; personal/team require memorix_session_start with joinTeam=true.',
         ),
+        longTerm: z.object({
+          kind: z.enum(['episodic', 'semantic', 'procedural']).describe('Cognitive kind for an additional long-term candidate.'),
+          scope: z.enum(['project', 'user', 'team']).optional().default('project').describe('Long-term scope. User capture is private source evidence and needs a bound agent identity.'),
+          tags: z.array(z.string()).optional().describe('Small set of retrieval tags for the candidate.'),
+          applicability: z.string().optional().describe('When this durable fact or procedure applies.'),
+        }).optional().describe('Optional explicit request to create a source-backed long-term candidate alongside this observation. Candidates are not automatically injected.'),
         overrideReadOnly: z.boolean().optional().describe(
           'Use only when the user explicitly asks to save memory during a read-only or no-modification task.',
         ),
       },
     },
-    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility, overrideReadOnly }) => {
+    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility, longTerm, overrideReadOnly }) => {
       const unresolved = requireResolvedProject('store memory in the current project');
       if (unresolved) return unresolved;
       const readOnlyBoundary = blockReadOnlyAutopilotWrite(overrideReadOnly);
       if (readOnlyBoundary) return readOnlyBoundary;
-      const requestedVisibility = (visibility ?? 'project') as 'personal' | 'project' | 'team';
+      // Keep visibility undefined for an ordinary upsert. storeObservation then
+      // preserves an existing targeted/personal record instead of silently
+      // widening it to project scope. A long-term scope is explicit and must
+      // still set the source observation's corresponding visibility.
+      const requestedVisibility = (
+        longTerm?.scope === 'user'
+          ? 'personal'
+          : longTerm?.scope === 'team'
+            ? 'team'
+            : visibility
+      ) as 'personal' | 'project' | 'team' | undefined;
+      const effectiveVisibility = requestedVisibility ?? 'project';
       const reader = getObservationReader();
-      if (requestedVisibility !== 'project' && !currentAgentId) {
+      if (effectiveVisibility !== 'project' && !currentAgentId) {
         return {
           content: [{ type: 'text' as const, text: 'Personal or team memory requires memorix_session_start with joinTeam=true so Memorix can bind an owner.' }],
           isError: true as const,
         };
       }
-      if (requestedVisibility === 'team' && !reader.isTeamMember) {
+      if (effectiveVisibility === 'team' && !reader.isTeamMember) {
         return {
           content: [{ type: 'text' as const, text: 'Team memory requires an active coordination membership in the current project.' }],
           isError: true as const,
         };
       }
+      if (longTerm?.scope === 'team' && !reader.isTeamMember) {
+        return {
+          content: [{ type: 'text' as const, text: 'Team long-term memory requires an active coordination membership in the current project.' }],
+          isError: true as const,
+        };
+      }
       try {
       return await withFreshIndex(async () => {
 
@@ -752,7 +776,7 @@ export async function createMemorixServer(
       // ── Formation Pipeline (active mode: decides storage) ─────────────
       let formationResult: FormedMemory | null = null;
       let formationNote = '';
-      if (useFormation && !topicKey && !progress) {
+      if (useFormation && !topicKey && !progress && !longTerm) {
         let currentFormationStage: FormationStage | 'setup' = 'setup';
         const completedFormationStages: Partial<Record<FormationStage, number>> = {};
         const formationStartTime = Date.now();
@@ -915,7 +939,7 @@ export async function createMemorixServer(
       // This keeps memory count low and prevents duplication (Mem0-style).
       let compactAction = '';
       let compactMerged = false;
-      if (!useFormation && !topicKey && !progress) {
+      if (!useFormation && !topicKey && !progress && !longTerm) {
         try {
           const searchResult = await compactSearch({
             query: `${title} ${narrative.substring(0, 200)}`,
@@ -1094,10 +1118,33 @@ export async function createMemorixServer(
         sourceDetail: 'explicit',
         valueCategory: formationResult?.evaluation.category,
         createdByAgentId: currentAgentId,
-        visibility,
+        visibility: requestedVisibility,
         visibilityReader: reader,
       });
 
+      let longTermNote = '';
+      if (longTerm) {
+        try {
+          const { promoteObservationToLongTermMemory } = await import('./memory/long-term.js');
+          const promoted = await promoteObservationToLongTermMemory({
+            dataDir: projectDir,
+            observation: obs,
+            scope: longTerm.scope,
+            kind: longTerm.kind,
+            tags: longTerm.tags,
+            applicability: longTerm.applicability,
+            reader: {
+              projectId: project.id,
+              ...(reader.agentId ? { agentId: reader.agentId } : {}),
+              ...(reader.isTeamMember ? { isTeamMember: true } : {}),
+            },
+          });
+          longTermNote = `\nLong-term candidate: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}). Review it with the CLI before it is delivered automatically.`;
+        } catch (longTermError) {
+          longTermNote = `\n[WARN] Observation stored, but long-term candidate was not created: ${longTermError instanceof Error ? longTermError.message : 'unknown error'}`;
+        }
+      }
+
       // Add a reference to the entity's observations
       await graphManager.addObservations([
         { entityName, contents: [`[#${obs.id}] ${title}`] },
@@ -1123,7 +1170,7 @@ export async function createMemorixServer(
       // ── Formation Pipeline (shadow/fallback mode: observe only) ─────
       // Fire-and-forget: runs after storage to collect metrics.
       // Never blocks the MCP response — purely for A/B comparison data.
-      if (!useFormation && !topicKey && !progress) {
+      if (!useFormation && !topicKey && !progress && !longTerm) {
         const shadowFormation = async () => {
           let oldCompactDecision: { action: string, targetId?: number, reason?: string, durationMs?: number } | null = null;
           try {
@@ -1215,7 +1262,7 @@ export async function createMemorixServer(
         content: [
           {
             type: 'text' as const,
-            text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)\nEntity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ''}${compactAction}${compressionNote}${enrichment}${formationNote}${attributionWarning}`,
+            text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)\nEntity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ''}${compactAction}${compressionNote}${enrichment}${formationNote}${attributionWarning}${longTermNote}`,
           },
         ],
       };
@@ -1667,6 +1714,7 @@ export async function createMemorixServer(
         ...(external.caution
           ? { runtimeCautions: [{ kind: 'external-codegraph-fallback' as const, message: external.caution }] }
           : {}),
+        reader: getObservationReader(),
       });
       const text = buildContextPackPrompt(pack);
 
@@ -2475,11 +2523,11 @@ export async function createMemorixServer(
     {
       title: 'Memory Details',
       description:
-        'Fetch full observation or mini-skill details — includes source kind (explicit memory / hook trace / git evidence), ' +
+        'Fetch full observation, mini-skill, or curated durable-memory details — includes source kind (explicit memory / hook trace / git evidence), ' +
         'value category, and cross-references (~500-1000 tokens each). ' +
         'Do not re-fetch content already covered by a complete memorix_project_context brief unless a specific fact is still missing or the user asks for deeper history; provide purpose when intentionally expanding. ' +
         'Always use memorix_search first to find relevant IDs, then fetch only what you need. ' +
-        'Accepts typed refs from search results (e.g. "obs:42", "skill:3") via the typedRefs field, ' +
+        'Accepts typed refs from search results (e.g. "obs:42", "skill:3") and durable refs from a project brief (e.g. "durable:<uuid>") via the typedRefs field, ' +
         'or legacy numeric ids / object refs for backward compatibility.',
       inputSchema: {
         ids: z.array(z.number()).optional().describe('Observation IDs to fetch (legacy, from memorix_search results)'),
@@ -2489,7 +2537,7 @@ export async function createMemorixServer(
             projectId: z.string().optional().describe('Project ID for global-search disambiguation'),
           }),
         ).optional().describe('Explicit observation refs. Prefer this for global search results.'),
-        typedRefs: z.array(z.string()).optional().describe('Typed memory refs from search results, e.g. "obs:42", "skill:3", "obs:42@org/proj"'),
+        typedRefs: z.array(z.string()).optional().describe('Typed memory refs from search results or a project brief, e.g. "obs:42", "skill:3", "durable:<uuid>", "obs:42@org/proj"'),
         purpose: z.string().optional().describe(
           'Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user\'s explicit request.',
         ),
@@ -2503,15 +2551,20 @@ export async function createMemorixServer(
       const safeIds = coerceNumberArray(ids);
       const safeRefs = coerceObservationRefs(refs);
       const safeTypedRefs = coerceStringArray(typedRefs);
+      const durableIds = safeTypedRefs.flatMap((ref) => {
+        const match = /^durable:([0-9a-f-]{36})$/i.exec(ref.trim());
+        return match ? [match[1]] : [];
+      });
+      const observationTypedRefs = safeTypedRefs.filter(ref => !/^durable:/i.test(ref.trim()));
       const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id)
-        || safeTypedRefs.some((ref) => ref.includes('@') && !ref.endsWith(`@${project.id}`));
+        || observationTypedRefs.some((ref) => ref.includes('@') && !ref.endsWith(`@${project.id}`));
       if (!hasCrossProjectRef) {
         const boundary = requireExplicitAutopilotExpansion('memorix_detail', purpose);
         if (boundary) return boundary;
         const requestedObservationIds = [
           ...safeIds,
           ...safeRefs.map(ref => ref.id),
-          ...safeTypedRefs.flatMap((ref) => {
+          ...observationTypedRefs.flatMap((ref) => {
             const match = /^obs:(\d+)(?:@.+)?$/i.exec(ref.trim());
             return match ? [Number(match[1])] : [];
           }),
@@ -2520,18 +2573,47 @@ export async function createMemorixServer(
         if (duplicate) return duplicate;
       }
 
-      // Priority: typedRefs > refs > ids (each is a complete, homogeneous input path)
-      let result;
+      const formatted: string[] = [];
       try {
-        const reader = getObservationReader(hasCrossProjectRef ? 'global' : 'project');
-        if (safeTypedRefs.length > 0) {
-          // Pass typed ref strings directly — compactDetail handles parsing
-          result = await compactDetail(safeTypedRefs, { reader });
-        } else if (safeRefs.length > 0) {
-          result = await compactDetail(safeRefs, { reader });
-        } else {
-          // Bare numeric IDs are scoped to the current project
-          result = await compactDetail(safeIds.map(id => ({ id, projectId: project.id })), { reader });
+        if (durableIds.length > 0) {
+          const [{ getLongTermMemoryDetail }, { resolveLocalMemoryOwner }] = await Promise.all([
+            import('./memory/long-term.js'),
+            import('./memory/owner.js'),
+          ]);
+          const owner = await resolveLocalMemoryOwner(projectDir, { create: false });
+          const observationReader = getObservationReader();
+          const durableReader = {
+            projectId: project.id,
+            ...(owner ? { ownerId: owner.id } : {}),
+            ...(observationReader.agentId ? { agentId: observationReader.agentId } : {}),
+            ...(observationReader.isTeamMember ? { isTeamMember: true } : {}),
+          };
+          const details = await Promise.all(durableIds.slice(0, 5).map(async (id) => {
+            try {
+              return await getLongTermMemoryDetail({ dataDir: projectDir, id, reader: durableReader });
+            } catch (error) {
+              return { error: error instanceof Error ? error.message : String(error), id };
+            }
+          }));
+          formatted.push(JSON.stringify({ durableMemory: details }, null, 2));
+        }
+
+        if (observationTypedRefs.length > 0 || safeRefs.length > 0 || safeIds.length > 0) {
+          const reader = getObservationReader(hasCrossProjectRef ? 'global' : 'project');
+          const result = observationTypedRefs.length > 0
+            ? await compactDetail(observationTypedRefs, { reader })
+            : safeRefs.length > 0
+              ? await compactDetail(safeRefs, { reader })
+              : await compactDetail(safeIds.map(id => ({ id, projectId: project.id })), { reader });
+          formatted.push(
+            result.documents.length > 0
+              ? result.formatted
+              : observationTypedRefs.length > 0
+                ? `No memories found for refs: ${observationTypedRefs.join(', ')}`
+                : safeRefs.length > 0
+                  ? `No memories found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? 'current'}#${ref.id}`).join(', ')}`
+                  : `No memories found for IDs: ${safeIds.join(', ')}`,
+          );
         }
       } catch (err) {
         return { content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }], isError: true };
@@ -2541,8 +2623,8 @@ export async function createMemorixServer(
         content: [
           {
             type: 'text' as const,
-            text: result.documents.length > 0
-              ? result.formatted
+            text: formatted.length > 0
+              ? formatted.join('\n\n')
               : safeTypedRefs.length > 0
                 ? `No memories found for refs: ${safeTypedRefs.join(', ')}`
                 : safeRefs.length > 0

package/src/store/sqlite-db.ts

@@ -497,6 +497,62 @@ const CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE = [
   ');',
 ].join('\n');
 
+// ── 1.3 Durable cognitive memory ───────────────────────────────────
+
+const CREATE_LONG_TERM_MEMORIES_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memories (
+  id                TEXT PRIMARY KEY,
+  originProjectId   TEXT NOT NULL,
+  ownerId           TEXT NOT NULL,
+  scope             TEXT NOT NULL,
+  kind              TEXT NOT NULL,
+  state             TEXT NOT NULL,
+  portability       TEXT NOT NULL DEFAULT 'project-bound',
+  title             TEXT NOT NULL,
+  content           TEXT NOT NULL,
+  factsJson         TEXT NOT NULL DEFAULT '[]',
+  tagsJson          TEXT NOT NULL DEFAULT '[]',
+  applicability     TEXT,
+  origin            TEXT NOT NULL,
+  createdAt         TEXT NOT NULL,
+  updatedAt         TEXT NOT NULL,
+  qualifiedAt       TEXT,
+  approvedAt        TEXT,
+  archivedAt        TEXT,
+  supersededBy      TEXT,
+  lastValidatedAt   TEXT,
+  accessCount       INTEGER NOT NULL DEFAULT 0,
+  lastAccessedAt    TEXT
+);
+`;
+
+const CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memory_evidence (
+  id             TEXT PRIMARY KEY,
+  memoryId       TEXT NOT NULL,
+  kind           TEXT NOT NULL,
+  referenceId    TEXT NOT NULL,
+  relation       TEXT NOT NULL,
+  locator        TEXT,
+  capturedHash   TEXT,
+  createdAt      TEXT NOT NULL,
+  FOREIGN KEY (memoryId) REFERENCES long_term_memories(id) ON DELETE CASCADE
+);
+`;
+
+const CREATE_LONG_TERM_MEMORY_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memory_events (
+  id          TEXT PRIMARY KEY,
+  memoryId    TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  fromState   TEXT,
+  toState     TEXT,
+  detail      TEXT,
+  createdAt   TEXT NOT NULL,
+  FOREIGN KEY (memoryId) REFERENCES long_term_memories(id) ON DELETE CASCADE
+);
+`;
+
 // ── Runtime maintenance jobs ───────────────────────────────────────
 
 const CREATE_MAINTENANCE_JOBS_TABLE = `
@@ -599,6 +655,11 @@ CREATE INDEX IF NOT EXISTS idx_knowledge_page_claims_claim ON knowledge_page_cla
 CREATE INDEX IF NOT EXISTS idx_knowledge_proposals_workspace_status ON knowledge_proposals(workspaceId, status, createdAt DESC);
 CREATE INDEX IF NOT EXISTS idx_knowledge_workflows_workspace_status ON knowledge_workflows(workspaceId, status, updatedAt DESC);
 CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowledge_workflow_runs(projectId, workflowId, startedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_owner_state ON long_term_memories(ownerId, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_project_state ON long_term_memories(originProjectId, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_scope_portability ON long_term_memories(scope, portability, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memory_evidence_memory ON long_term_memory_evidence(memoryId, createdAt);
+CREATE INDEX IF NOT EXISTS idx_long_term_memory_events_memory ON long_term_memory_events(memoryId, createdAt);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_ready ON maintenance_jobs(status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_project ON maintenance_jobs(project_id, status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_targets(updated_at);
@@ -705,6 +766,19 @@ const SCHEMA_MIGRATIONS: SchemaMigration[] = [
       db.exec('CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key)');
     },
   },
+  {
+    id: '1.3-long-term-memory',
+    apply: (db) => {
+      db.exec(CREATE_LONG_TERM_MEMORIES_TABLE);
+      db.exec(CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE);
+      db.exec(CREATE_LONG_TERM_MEMORY_EVENTS_TABLE);
+      db.exec('CREATE INDEX IF NOT EXISTS idx_long_term_memories_owner_state ON long_term_memories(ownerId, state, updatedAt DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_long_term_memories_project_state ON long_term_memories(originProjectId, state, updatedAt DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_long_term_memories_scope_portability ON long_term_memories(scope, portability, state, updatedAt DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_long_term_memory_evidence_memory ON long_term_memory_evidence(memoryId, createdAt)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_long_term_memory_events_memory ON long_term_memory_events(memoryId, createdAt)');
+    },
+  },
 ];
 
 function applySchemaMigrations(db: any): void {

package/src/types.ts

@@ -648,3 +648,23 @@ export interface MCPConfigAdapter {
   /** Get the default config file path for this agent */
   getConfigPath(projectRoot?: string): string;
 }
+
+// Durable cognitive memory is intentionally kept in its own module so the
+// legacy Observation contract remains source/provenance focused.
+export type {
+  CreateLongTermMemoryInput,
+  LongTermMemory,
+  LongTermMemoryEvidence,
+  LongTermMemoryEvidenceInput,
+  LongTermMemoryEvidenceKind,
+  LongTermMemoryEvidenceRelation,
+  LongTermMemoryEvent,
+  LongTermMemoryEventKind,
+  LongTermMemoryKind,
+  LongTermMemoryOrigin,
+  LongTermMemoryPortability,
+  LongTermMemoryReader,
+  LongTermMemoryScope,
+  LongTermMemorySelection,
+  LongTermMemoryState,
+} from './memory/long-term-types.js';