dotmem 0.0.4 → 0.0.7

package/cli.js

@@ -1,4 +1,4 @@
-import { store, DEV, hlc, dispatch, idb, session, state, temporal } from 'memorio';
+import { store as store$1, DEV, hlc, dispatch, idb, session, state, temporal } from 'memorio';
 import process2 from 'process';
 import path from 'path';
 import fs from 'fs';
@@ -64,19 +64,19 @@ var init_journal = __esm({
           hlc: entry.hlc || hlc.serialize(hlc.tick())
         };
         const key = `${STORE_PREFIX(ns)}${row.id}`;
-        store.set(key, row);
-        const idx = store.get(INDEX_KEY(ns)) || [];
+        store$1.set(key, row);
+        const idx = store$1.get(INDEX_KEY(ns)) || [];
         if (!idx.includes(row.id)) idx.push(row.id);
-        store.set(INDEX_KEY(ns), idx);
+        store$1.set(INDEX_KEY(ns), idx);
         return row;
       },
       /** All pending (not-yet-synced) entries for the current namespace. */
       async pending() {
         const ns = namespace();
         const out = [];
-        const idx = store.get(INDEX_KEY(ns)) || [];
+        const idx = store$1.get(INDEX_KEY(ns)) || [];
         for (const id of idx) {
-          const raw = store.get(`${STORE_PREFIX(ns)}${id}`);
+          const raw = store$1.get(`${STORE_PREFIX(ns)}${id}`);
           if (!raw) continue;
           const e = parseEntry(raw);
           if (e && e.sync !== "synced") out.push(e);
@@ -99,31 +99,31 @@ var init_journal = __esm({
         if (!ids.length) return 0;
         const ns = namespace();
         let count = 0;
-        const idx = store.get(INDEX_KEY(ns)) || [];
+        const idx = store$1.get(INDEX_KEY(ns)) || [];
         for (const id of idx) {
           if (!ids.includes(id)) continue;
           const key = `${STORE_PREFIX(ns)}${id}`;
-          const raw = store.get(key);
+          const raw = store$1.get(key);
           if (!raw) continue;
           const e = parseEntry(raw);
           if (!e || e.sync === "synced") continue;
           e.sync = "synced";
-          store.set(key, e);
+          store$1.set(key, e);
           count++;
         }
         return count;
       },
       async get(id) {
         const ns = namespace();
-        const raw = store.get(`${STORE_PREFIX(ns)}${id}`);
+        const raw = store$1.get(`${STORE_PREFIX(ns)}${id}`);
         return parseEntry(raw ?? "");
       },
       /** Remove all journal rows for the current namespace. */
       async clear() {
         const ns = namespace();
-        const idx = store.get(INDEX_KEY(ns)) || [];
-        for (const id of idx) store.remove(`${STORE_PREFIX(ns)}${id}`);
-        store.remove(INDEX_KEY(ns));
+        const idx = store$1.get(INDEX_KEY(ns)) || [];
+        for (const id of idx) store$1.remove(`${STORE_PREFIX(ns)}${id}`);
+        store$1.remove(INDEX_KEY(ns));
       },
       /**
        * Reconcile the local journal against the configured provider. Pushes pending
@@ -202,7 +202,7 @@ var init_journal = __esm({
        */
       async status() {
         try {
-          const capabilities = store.capabilities?.();
+          const capabilities = store$1.capabilities?.();
           return capabilities?.persistent ? "store" : "memory";
         } catch {
           return "memory";
@@ -6262,8 +6262,8 @@ var init_user_identity = __esm({
   "core/knowledge/user-identity.ts"() {
     USER_IDENTITY_KEY = "__dotmem_user_identity__";
     identityStore = null;
-    configureUserIdentityStore = /* @__PURE__ */ __name((store5) => {
-      identityStore = store5;
+    configureUserIdentityStore = /* @__PURE__ */ __name((store6) => {
+      identityStore = store6;
     }, "configureUserIdentityStore");
     requireStore = /* @__PURE__ */ __name(() => {
       if (!identityStore) {
@@ -8688,6 +8688,19 @@ async function readFile6(path3) {
     return null;
   }
 }
+async function writeFile6(path3, content) {
+  const fs3 = await import('fs/promises');
+  const dir = path3.replace(/[\\/][^\\/]+$/, "");
+  await fs3.mkdir(dir, { recursive: true });
+  const temporary = `${path3}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    await fs3.writeFile(temporary, content, "utf8");
+    await fs3.rename(temporary, path3);
+  } catch {
+    await fs3.rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error(`Failed to write exemplars file at ${path3}`);
+  }
+}
 function emptyStore() {
   return { version: EXEMPLARS_FORMAT_VERSION, exemplars: {} };
 }
@@ -8752,9 +8765,53 @@ async function loadExemplars() {
     return emptyStore();
   }
 }
+async function saveExemplars(store6) {
+  const validated = validateStore(store6);
+  await writeFile6(resolveExemplarsPath(), JSON.stringify(validated, null, 2));
+}
+async function addExemplar(exemplar) {
+  const store6 = await loadExemplars();
+  if (store6.exemplars[exemplar.id]) {
+    throw new Error(`Exemplar ${exemplar.id} already exists`);
+  }
+  if (exemplar.sourceReference) {
+    const existingRef = Object.values(store6.exemplars).find(
+      (e) => e.sourceReference === exemplar.sourceReference
+    );
+    if (existingRef) {
+      throw new Error(`Exemplar with source reference ${exemplar.sourceReference} already exists (id: ${existingRef.id})`);
+    }
+  }
+  const full = {
+    ...exemplar,
+    type: "interaction-exemplar",
+    revision: 1
+  };
+  store6.exemplars[exemplar.id] = full;
+  await saveExemplars(store6);
+  return full;
+}
+async function updateExemplar(id, updates) {
+  const store6 = await loadExemplars();
+  const existing = store6.exemplars[id];
+  if (!existing) {
+    throw new Error(`Exemplar ${id} not found`);
+  }
+  const updated = {
+    ...existing,
+    ...updates,
+    id: existing.id,
+    type: "interaction-exemplar",
+    createdAt: existing.createdAt,
+    revision: (updates.revision ?? existing.revision) + 1
+  };
+  store6.exemplars[id] = updated;
+  await saveExemplars(store6);
+  return updated;
+}
 async function searchExemplars(options = {}) {
-  const store5 = await loadExemplars();
-  const all = Object.values(store5.exemplars);
+  const store6 = await loadExemplars();
+  const all = Object.values(store6.exemplars);
   const filtered = all.filter((exemplar) => {
     if (options.minSignificance !== void 0 && exemplar.significance < options.minSignificance) {
       return false;
@@ -8814,10 +8871,14 @@ var init_exemplars = __esm({
     __name(joinPath9, "joinPath");
     __name(resolveExemplarsPath, "resolveExemplarsPath");
     __name(readFile6, "readFile");
+    __name(writeFile6, "writeFile");
     __name(emptyStore, "emptyStore");
     __name(validateExemplar, "validateExemplar");
     __name(validateStore, "validateStore");
     __name(loadExemplars, "loadExemplars");
+    __name(saveExemplars, "saveExemplars");
+    __name(addExemplar, "addExemplar");
+    __name(updateExemplar, "updateExemplar");
     __name(searchExemplars, "searchExemplars");
     __name(projectExemplar, "projectExemplar");
     __name(projectExemplarContext, "projectExemplarContext");
@@ -8840,6 +8901,19 @@ async function readFile7(path3) {
     return null;
   }
 }
+async function writeFile7(path3, content) {
+  const fs3 = await import('fs/promises');
+  const dir = path3.replace(/[\\/][^\\/]+$/, "");
+  await fs3.mkdir(dir, { recursive: true });
+  const temporary = `${path3}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    await fs3.writeFile(temporary, content, "utf8");
+    await fs3.rename(temporary, path3);
+  } catch {
+    await fs3.rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error(`Failed to write personality anchor at ${path3}`);
+  }
+}
 function emptyAnchor() {
   const epoch = "1970-01-01T00:00:00.000Z";
   return {
@@ -8972,6 +9046,33 @@ async function loadPersonalityAnchor() {
     return emptyAnchor();
   }
 }
+async function savePersonalityAnchor(anchor) {
+  const validated = validateAnchor(anchor);
+  const dirPath = resolveUserDotMemPath();
+  const fs3 = await import('fs/promises');
+  await fs3.mkdir(dirPath, { recursive: true });
+  await writeFile7(resolvePersonalityAnchorPath(), JSON.stringify(validated, null, 2));
+}
+async function updatePersonalityAnchor(updates) {
+  const existing = await loadPersonalityAnchor();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const updated = {
+    ...existing,
+    identity: {
+      communicationStyle: updates.communicationStyle ?? existing.identity.communicationStyle,
+      durablePreferences: updates.durablePreferences ?? existing.identity.durablePreferences,
+      interactionBoundaries: updates.interactionBoundaries ?? existing.identity.interactionBoundaries
+    },
+    metadata: {
+      ...existing.metadata,
+      updatedAt: now2,
+      revision: existing.metadata.revision + 1,
+      sourceReferences: updates.sourceReferences ? [.../* @__PURE__ */ new Set([...existing.metadata.sourceReferences, ...updates.sourceReferences])] : existing.metadata.sourceReferences
+    }
+  };
+  await savePersonalityAnchor(updated);
+  return updated;
+}
 function projectPersonalityAnchor(anchor, options) {
   const maxChars = options?.maxCharacters ?? 4e3;
   const hasContent = anchor.identity.communicationStyle.length > 0 || anchor.identity.durablePreferences.length > 0 || anchor.identity.interactionBoundaries.length > 0;
@@ -9026,12 +9127,15 @@ var init_personality_anchor = __esm({
     __name(joinPath10, "joinPath");
     __name(resolvePersonalityAnchorPath, "resolvePersonalityAnchorPath");
     __name(readFile7, "readFile");
+    __name(writeFile7, "writeFile");
     __name(emptyAnchor, "emptyAnchor");
     __name(validateCommunicationStyle, "validateCommunicationStyle");
     __name(validateDurablePreference, "validateDurablePreference");
     __name(validateInteractionBoundary, "validateInteractionBoundary");
     __name(validateAnchor, "validateAnchor");
     __name(loadPersonalityAnchor, "loadPersonalityAnchor");
+    __name(savePersonalityAnchor, "savePersonalityAnchor");
+    __name(updatePersonalityAnchor, "updatePersonalityAnchor");
     __name(projectPersonalityAnchor, "projectPersonalityAnchor");
     __name(calculateAnchorBudget, "calculateAnchorBudget");
   }
@@ -9567,7 +9671,7 @@ var init_knowledge_runtime = __esm({
         __name(this, "StoreKnowledgeRepository");
       }
       async load() {
-        const raw = store.get(KNOWLEDGE_STATE_KEY);
+        const raw = store$1.get(KNOWLEDGE_STATE_KEY);
         if (!raw) return { version: 0, claims: [] };
         return typeof raw === "string" ? JSON.parse(raw) : raw;
       }
@@ -9577,7 +9681,7 @@ var init_knowledge_runtime = __esm({
           if (current.version !== expectedVersion) {
             throw new Error(`Stale update: expected persisted version ${expectedVersion}, received ${current.version}`);
           }
-          store.set(KNOWLEDGE_STATE_KEY, state2);
+          store$1.set(KNOWLEDGE_STATE_KEY, state2);
         }, "write");
         const previous = knowledgeSaveQueue;
         knowledgeSaveQueue = previous.then(write, write);
@@ -9723,27 +9827,27 @@ var init_policy2 = __esm({
       }
     }, "auditPolicyAction");
     resolveOverrides = /* @__PURE__ */ __name(async (namespace2, now2 = () => /* @__PURE__ */ new Date()) => {
-      const store5 = await getPolicyStore();
+      const store6 = await getPolicyStore();
       const namespaces = namespace2 ? [namespace2] : POLICY_NAMESPACES;
-      const documents = await Promise.all(namespaces.map((entry) => store5.load(entry)));
+      const documents = await Promise.all(namespaces.map((entry) => store6.load(entry)));
       return documents.flatMap((document) => document.overrides.map(
         (override) => resolveOverrideState(override, document.records.find((record) => record.id === override.targetPolicyId), now2)
       )).sort((left, right) => left.override.id.localeCompare(right.override.id));
     }, "resolveOverrides");
     policy = {
       async assign(input, namespace2 = "operator", basedOnRevision) {
-        const store5 = await getPolicyStore();
-        const record = await store5.assign(input, namespace2, basedOnRevision);
+        const store6 = await getPolicyStore();
+        const record = await store6.assign(input, namespace2, basedOnRevision);
         auditPolicyAction("policy.assign", record.id);
         return record;
       },
       async list() {
-        const store5 = await getPolicyStore();
-        return store5.list();
+        const store6 = await getPolicyStore();
+        return store6.list();
       },
       async remove(id, namespace2 = "operator", basedOnRevision) {
-        const store5 = await getPolicyStore();
-        await store5.remove(id, namespace2, basedOnRevision);
+        const store6 = await getPolicyStore();
+        await store6.remove(id, namespace2, basedOnRevision);
         auditPolicyAction("policy.remove", id);
       },
       /**
@@ -9757,16 +9861,16 @@ var init_policy2 = __esm({
        * the durable audit trail with a terminal CLEAR entry.
        */
       async clear(authority) {
-        const store5 = await getPolicyStore();
-        await store5.clear(authority);
+        const store6 = await getPolicyStore();
+        await store6.clear(authority);
         auditPolicyAction("policy.clear", "policy");
       },
       async evaluate(event, payload) {
-        const store5 = await getPolicyStore();
+        const store6 = await getPolicyStore();
         const [state2, policies, overrides] = await Promise.all([
           loadCombinedKnowledgeState(),
-          store5.list(),
-          store5.listOverrides()
+          store6.list(),
+          store6.listOverrides()
         ]);
         const claims = activeClaims(state2);
         return evaluatePolicies({ event, claims, policies, overrides, payload });
@@ -9788,14 +9892,14 @@ var init_policy2 = __esm({
        */
       override: {
         async grant(input, namespace2 = "operator", basedOnRevision) {
-          const store5 = await getPolicyStore();
-          const override = await store5.grantOverride(input, namespace2, basedOnRevision);
+          const store6 = await getPolicyStore();
+          const override = await store6.grantOverride(input, namespace2, basedOnRevision);
           auditPolicyAction("policy.override", override.id);
           return override;
         },
         async revoke(input, namespace2 = "operator", basedOnRevision) {
-          const store5 = await getPolicyStore();
-          const override = await store5.revokeOverride(input, namespace2, basedOnRevision);
+          const store6 = await getPolicyStore();
+          const override = await store6.revokeOverride(input, namespace2, basedOnRevision);
           auditPolicyAction("policy.revoke", override.id);
           return override;
         },
@@ -9803,8 +9907,8 @@ var init_policy2 = __esm({
           return resolveOverrides(namespace2);
         },
         async effective(event, namespace2) {
-          const store5 = await getPolicyStore();
-          const states = await store5.effectiveState(namespace2);
+          const store6 = await getPolicyStore();
+          const states = await store6.effectiveState(namespace2);
           if (event === void 0) return states;
           const canonical = event.trim();
           return states.filter((state2) => state2.event === canonical);
@@ -9817,8 +9921,8 @@ var init_policy2 = __esm({
        * additional best-effort sink, and this is the durable record.
        */
       async audit(namespace2) {
-        const store5 = await getPolicyStore();
-        return store5.auditTrail(namespace2);
+        const store6 = await getPolicyStore();
+        return store6.auditTrail(namespace2);
       },
       contract() {
         return MEMORY_PROJECTION_CONTRACT;
@@ -9951,7 +10055,7 @@ async function saveToScope(entry) {
       session.set(storageKey, serialized);
       break;
     case "local":
-      store.set(storageKey, serialized);
+      store$1.set(storageKey, serialized);
       break;
     case "durable":
       await idb.set("memories", storageKey, serialized);
@@ -9972,7 +10076,7 @@ async function loadFromScope(id, scope, isSuperseded = false) {
       raw = session.get(storageKey);
       break;
     case "local":
-      raw = store.get(storageKey);
+      raw = store$1.get(storageKey);
       break;
     case "durable":
       raw = await idb.get("memories", storageKey);
@@ -10014,7 +10118,7 @@ async function removeFromScope(id, scope, isSuperseded = false) {
       session.remove(storageKey);
       break;
     case "local":
-      store.remove(storageKey);
+      store$1.remove(storageKey);
       break;
     case "durable":
       await idb.deleteKey("memories", storageKey);
@@ -10024,7 +10128,7 @@ async function removeFromScope(id, scope, isSuperseded = false) {
 }
 async function getAllIndexes() {
   try {
-    const raw = store.get(MEMORY_INDEX_KEY);
+    const raw = store$1.get(MEMORY_INDEX_KEY);
     if (!raw) return {};
     return JSON.parse(raw);
   } catch (err2) {
@@ -10035,7 +10139,7 @@ async function getAllIndexes() {
 async function updateIndex(id, scope, isSuperseded = false) {
   const index = await getAllIndexes();
   index[id] = { scope, superseded: isSuperseded };
-  store.set(MEMORY_INDEX_KEY, JSON.stringify(index));
+  store$1.set(MEMORY_INDEX_KEY, JSON.stringify(index));
 }
 async function removeFromIndex(id, isSuperseded = false) {
   const index = await getAllIndexes();
@@ -10047,7 +10151,7 @@ async function removeFromIndex(id, isSuperseded = false) {
       delete index[id];
     }
   }
-  store.set(MEMORY_INDEX_KEY, JSON.stringify(index));
+  store$1.set(MEMORY_INDEX_KEY, JSON.stringify(index));
 }
 async function loadAll() {
   const index = await getAllIndexes();
@@ -10288,7 +10392,7 @@ var init_entries = __esm({
         for (const [id, info] of Object.entries(index)) {
           await removeFromScope(id, info.scope, info.superseded);
         }
-        store.remove(MEMORY_INDEX_KEY);
+        store$1.remove(MEMORY_INDEX_KEY);
       },
       async _getEntry(key) {
         return getEntry(key);
@@ -11232,6 +11336,783 @@ var init_seed = __esm({
     }, "injectJoySeed");
   }
 });
+function generateId() {
+  return `capture-${hlc.serialize(hlc.tick())}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeText(text) {
+  return text.normalize("NFKC").toLocaleLowerCase("en-US").replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize(text) {
+  return new Set(normalizeText(text).split(" ").filter((t) => t.length > 2));
+}
+function jaccardSimilarity(a, b) {
+  const ta = tokenize(a);
+  const tb = tokenize(b);
+  if (ta.size === 0 && tb.size === 0) return 1;
+  if (ta.size === 0 || tb.size === 0) return 0;
+  const intersection = new Set([...ta].filter((x2) => tb.has(x2)));
+  const union = /* @__PURE__ */ new Set([...ta, ...tb]);
+  return intersection.size / union.size;
+}
+function containsPhrase2(text, phrase) {
+  const t = normalizeText(text);
+  const p = normalizeText(phrase);
+  return t.includes(p);
+}
+function detectExplicitInstructions(text, source) {
+  const instructions = [];
+  for (const pattern of REMEMBER_PATTERNS) {
+    if (pattern.test(text)) {
+      instructions.push({
+        type: "remember",
+        content: text,
+        source,
+        timestamp: nowIso()
+      });
+      break;
+    }
+  }
+  for (const pattern of DO_NOT_REMEMBER_PATTERNS) {
+    if (pattern.test(text)) {
+      instructions.push({
+        type: "do-not-remember",
+        content: text,
+        source,
+        timestamp: nowIso()
+      });
+      break;
+    }
+  }
+  return instructions;
+}
+function classifyCategory(text, explicitInstructions) {
+  const lower = text.toLocaleLowerCase("en-US");
+  if (explicitInstructions.some((i2) => i2.type === "do-not-remember")) {
+    return "temporary_context";
+  }
+  if (explicitInstructions.some((i2) => i2.type === "remember")) {
+    if (/prefer|prefers|like|likes|favorite|always|never/i.test(lower)) {
+      return "preference";
+    }
+    if (/decided|decision|agreed|chose|adopt/i.test(lower)) {
+      return "decision";
+    }
+    return "fact";
+  }
+  const scores = {};
+  for (const cat of Object.keys(CATEGORY_KEYWORDS)) {
+    scores[cat] = CATEGORY_KEYWORDS[cat].filter((kw) => containsPhrase2(lower, kw)).length;
+  }
+  if (/probably|likely|maybe|perhaps|seems|appears|might|could be/i.test(lower)) {
+    scores.inference += 3;
+  }
+  if (text.includes("?")) {
+    scores.question += 3;
+  }
+  if (/decided|decision|agreed|chose|adopt|will use|going with|resolve|settled/i.test(lower)) {
+    scores.decision += 3;
+  }
+  if (/prefer|prefers|like|likes|favorite|always|never|don.t like|dislike/i.test(lower)) {
+    scores.preference += 3;
+  }
+  if (/still need to|pending|waiting for|todo|to do|unresolved|outstanding|follow.?up|blocked/i.test(lower)) {
+    scores.open_loop += 3;
+  }
+  if (/remember when|we talked about|discussed|experienced|encountered|session|conversation/i.test(lower)) {
+    scores.experience += 2;
+  }
+  if (/repository|architecture|deploy|ci|pipeline/i.test(lower)) {
+    scores.project_context += 2;
+  }
+  if (/just for|this session|for now|temporary/i.test(lower)) {
+    scores.temporary_context += 3;
+  }
+  if (scores.fact > 0 && scores.project_context > 0 && scores.fact === scores.project_context) {
+    scores.fact += 1;
+  }
+  let bestCategory = "fact";
+  let bestScore = -1;
+  for (const [cat, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = cat;
+    }
+  }
+  if (bestScore === 0) return "fact";
+  return bestCategory;
+}
+function determineEpistemicType(category, text, explicitInstructions) {
+  if (explicitInstructions.some((i2) => i2.type === "remember")) {
+    return "human-stated";
+  }
+  if (category === "inference" || /probably|likely|maybe|perhaps|seems|appears/i.test(text)) {
+    return "inferred";
+  }
+  if (category === "question") return "observed";
+  return "observed";
+}
+function determineConfidence(category, epistemicType, _text) {
+  if (epistemicType === "human-stated") return "high";
+  if (epistemicType === "inferred") return "low";
+  if (category === "decision" || category === "preference") return "medium";
+  if (category === "question") return "medium";
+  if (category === "fact") return "medium";
+  return "low";
+}
+function extractEntities(text) {
+  const entities = [];
+  const seen = /* @__PURE__ */ new Set();
+  const capitalizedMatches = text.match(/\b[A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*\b/g) || [];
+  for (const match of capitalizedMatches) {
+    if (seen.has(match)) continue;
+    seen.add(match);
+    entities.push({
+      id: `entity-${normalizeText(match)}`,
+      type: "concept",
+      name: match,
+      aliases: [],
+      relationships: []
+    });
+  }
+  const quotedMatches = text.match(/["'`]([^"`']{2,})["'`]/g) || [];
+  for (const match of quotedMatches) {
+    const clean = match.replace(/["'`]/g, "");
+    if (seen.has(clean)) continue;
+    seen.add(clean);
+    entities.push({
+      id: `entity-${normalizeText(clean)}`,
+      type: "concept",
+      name: clean,
+      aliases: [],
+      relationships: []
+    });
+  }
+  return entities;
+}
+function extractRelationships(_text, entities) {
+  const relationships = [];
+  if (entities.length < 2) return relationships;
+  for (let i2 = 0; i2 < entities.length - 1; i2++) {
+    for (let j = i2 + 1; j < entities.length; j++) {
+      relationships.push({
+        from: entities[i2].id,
+        to: entities[j].id,
+        type: "related-to",
+        confidence: 0.5
+      });
+    }
+  }
+  return relationships;
+}
+async function findExistingSimilarItems(statement, category, existingItems, threshold) {
+  const matches2 = [];
+  for (const existing of existingItems) {
+    if (existing.category !== category) continue;
+    const similarity = jaccardSimilarity(statement, existing.statement);
+    if (similarity >= threshold) {
+      matches2.push({
+        existingId: existing.id,
+        existingStatement: existing.statement,
+        similarity,
+        matchType: similarity >= 0.95 ? "exact" : "semantic",
+        category: existing.category
+      });
+    }
+  }
+  return matches2;
+}
+async function findExistingMemoryEntries(statement, category) {
+  const matches2 = [];
+  try {
+    const all = await entries._loadAll();
+    for (const entry of all) {
+      if (entry.status !== "active") continue;
+      if (entry.type !== category && entry.type !== "fact") continue;
+      const entryText = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
+      const similarity = jaccardSimilarity(statement, entryText);
+      if (similarity >= DEFAULT_CONFIG.dedupSimilarityThreshold) {
+        matches2.push({
+          existingId: entry.id,
+          existingStatement: entryText,
+          similarity,
+          matchType: similarity >= 0.95 ? "exact" : "semantic",
+          category
+        });
+      }
+    }
+  } catch {
+  }
+  return matches2;
+}
+function shouldStoreInCoreMemory(category, epistemicType) {
+  return category === "preference" && epistemicType === "human-stated";
+}
+async function routeToStorage(item, adapters, config) {
+  const { category, epistemicType, statement, entities, provenance, confidence } = item;
+  const memKey = `capture:${item.id}`;
+  await entries.remember(memKey, {
+    id: item.id,
+    category,
+    statement,
+    entities,
+    relationships: item.relationships,
+    provenance,
+    confidence,
+    epistemicType,
+    capturedAt: provenance.capturedAt
+  }, {
+    id: item.id,
+    type: category === "preference" ? "preference" : category === "decision" ? "decision" : category === "fact" ? "fact" : "context",
+    confidence: confidence === "high" ? 1 : confidence === "medium" ? 0.7 : 0.4,
+    scope: category === "temporary_context" ? "session" : "local",
+    tags: [category, provenance.epistemicType, provenance.source.conversationId],
+    source: `capture:${provenance.source.conversationId}`
+  });
+  if (shouldStoreInCoreMemory(category, epistemicType)) {
+    try {
+      const anchor = await loadPersonalityAnchor();
+      const existingPref = anchor.identity.durablePreferences.find((p) => p.statement === statement);
+      if (!existingPref) {
+        await updatePersonalityAnchor({
+          durablePreferences: [
+            ...anchor.identity.durablePreferences,
+            {
+              id: item.id,
+              statement,
+              confidence: epistemicType,
+              evidence: [provenance.source.conversationId],
+              firstObserved: provenance.capturedAt,
+              lastConfirmed: provenance.capturedAt
+            }
+          ]
+        });
+      }
+    } catch {
+    }
+  }
+  if (category === "open_loop" && config.autoCreateLoops) {
+    try {
+      const existingLoops = await listLoops(true);
+      const alreadyExists = existingLoops.some((l) => l.text === statement);
+      if (!alreadyExists) {
+        await addLoop({
+          id: item.id,
+          text: statement,
+          waitor: "joy",
+          openedAt: provenance.capturedAt
+        });
+      }
+    } catch {
+    }
+  }
+  if (category === "experience" && config.autoCreateExemplars) {
+    try {
+      await addExemplar({
+        id: item.id,
+        source: {
+          conversationId: provenance.source.conversationId,
+          messageIds: provenance.source.messageIds
+        },
+        pattern: statement,
+        originalContent: statement,
+        sourceReference: `capture:${item.id}`,
+        retrievalHints: [statement, ...entities.map((e) => e.name)],
+        significance: confidence === "high" ? 0.8 : confidence === "medium" ? 0.5 : 0.3,
+        confidence: confidence === "high" ? 1 : confidence === "medium" ? 0.7 : 0.4,
+        provenance: epistemicType,
+        createdAt: provenance.capturedAt
+      });
+    } catch {
+    }
+  }
+  if (config.autoCreateClaims && (category === "fact" || category === "decision")) {
+    try {
+      await acquire.acquire({
+        id: `claim-${item.id}`,
+        knowledge: { statement, category },
+        applicability: { area: "project" },
+        evidence: [{
+          id: `ev-${item.id}`,
+          source: provenance.source.conversationId,
+          observedAt: provenance.capturedAt,
+          supports: statement
+        }],
+        epistemicType,
+        provenance: { source: "conversation-capture", detail: `category:${category}` },
+        acquiredAt: provenance.capturedAt,
+        scope: "project"
+      });
+    } catch {
+    }
+  }
+  dispatch.set("dotmem:capture:item-captured", {
+    detail: { id: item.id, category, statement }
+  });
+}
+async function captureConversation(messages, options) {
+  return captureEngine.captureConversation(messages, options);
+}
+async function captureTurn(text, options) {
+  return captureEngine.captureTurn(text, options);
+}
+var CAPTURE_STATE_KEY, DEFAULT_CONFIG, CATEGORY_KEYWORDS, REMEMBER_PATTERNS, DO_NOT_REMEMBER_PATTERNS, CaptureEngine, captureEngine;
+var init_capture_engine = __esm({
+  "core/memory/capture-engine.ts"() {
+    init_exemplars();
+    init_loops();
+    init_personality_anchor();
+    init_entries();
+    init_acquire();
+    CAPTURE_STATE_KEY = "__dotmem_capture_state__";
+    DEFAULT_CONFIG = {
+      minSignificance: 0.3,
+      maxItemsPerConversation: 50,
+      dedupSimilarityThreshold: 0.75,
+      preserveConflicts: true,
+      tempContextTtlMs: 24 * 60 * 60 * 1e3,
+      autoCreateExemplars: true,
+      autoCreateLoops: true,
+      autoCreateClaims: true
+    };
+    CATEGORY_KEYWORDS = {
+      fact: [
+        "is",
+        "are",
+        "was",
+        "were",
+        "uses",
+        "built with",
+        "depends on",
+        "located at",
+        "named",
+        "called",
+        "version",
+        "language",
+        "framework",
+        "test",
+        "testing"
+      ],
+      decision: [
+        "decided",
+        "decision",
+        "agreed",
+        "chose",
+        "selected",
+        "adopt",
+        "going with",
+        "will use",
+        "commit to",
+        "resolve",
+        "settled"
+      ],
+      experience: [
+        "remember when",
+        "we talked about",
+        "discussed",
+        "experienced",
+        "encountered",
+        "faced",
+        "went through",
+        "session",
+        "conversation"
+      ],
+      question: [
+        "?",
+        "how do",
+        "what is",
+        "why",
+        "when",
+        "where",
+        "which",
+        "can you",
+        "should we",
+        "is it possible"
+      ],
+      open_loop: [
+        "still need to",
+        "pending",
+        "waiting for",
+        "todo",
+        "to do",
+        "open",
+        "unresolved",
+        "outstanding",
+        "follow up",
+        "blocked"
+      ],
+      preference: [
+        "prefer",
+        "prefers",
+        "like",
+        "likes",
+        "favorite",
+        "always",
+        "never",
+        "don't like",
+        "dislike",
+        "style",
+        "habit"
+      ],
+      project_context: [
+        "project",
+        "repository",
+        "codebase",
+        "architecture",
+        "stack",
+        "deploy",
+        "ci",
+        "pipeline",
+        "package"
+      ],
+      temporary_context: [
+        "for now",
+        "just for",
+        "temporary",
+        "this session",
+        "currently",
+        "right now",
+        "at the moment",
+        "for this task"
+      ],
+      inference: [
+        "probably",
+        "likely",
+        "maybe",
+        "perhaps",
+        "seems",
+        "appears",
+        "suggests",
+        "indicates",
+        "implies",
+        "might",
+        "could be"
+      ]
+    };
+    REMEMBER_PATTERNS = [
+      /remember this/i,
+      /remember that/i,
+      /keep this in mind/i,
+      /don't forget/i,
+      /do not forget/i,
+      /store this/i,
+      /save this/i
+    ];
+    DO_NOT_REMEMBER_PATTERNS = [
+      /don't remember/i,
+      /do not remember/i,
+      /forget this/i,
+      /don't store/i,
+      /do not store/i,
+      /not relevant/i,
+      /ignore this/i,
+      /temporary only/i,
+      /this session only/i
+    ];
+    __name(generateId, "generateId");
+    __name(nowIso, "nowIso");
+    __name(normalizeText, "normalizeText");
+    __name(tokenize, "tokenize");
+    __name(jaccardSimilarity, "jaccardSimilarity");
+    __name(containsPhrase2, "containsPhrase");
+    __name(detectExplicitInstructions, "detectExplicitInstructions");
+    __name(classifyCategory, "classifyCategory");
+    __name(determineEpistemicType, "determineEpistemicType");
+    __name(determineConfidence, "determineConfidence");
+    __name(extractEntities, "extractEntities");
+    __name(extractRelationships, "extractRelationships");
+    __name(findExistingSimilarItems, "findExistingSimilarItems");
+    __name(findExistingMemoryEntries, "findExistingMemoryEntries");
+    __name(shouldStoreInCoreMemory, "shouldStoreInCoreMemory");
+    __name(routeToStorage, "routeToStorage");
+    CaptureEngine = class {
+      static {
+        __name(this, "CaptureEngine");
+      }
+      config;
+      adapters;
+      sessionContexts = /* @__PURE__ */ new Map();
+      constructor(config = {}, adapters) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.adapters = {
+          remember: entries.remember.bind(entries),
+          recall: entries.recall.bind(entries),
+          update: entries.update.bind(entries),
+          addExemplar: addExemplar.bind(null),
+          updateExemplar: updateExemplar.bind(null),
+          addLoop: addLoop.bind(null),
+          closeLoop: closeLoop.bind(null),
+          updatePersonalityAnchor: updatePersonalityAnchor.bind(null),
+          ...adapters
+        };
+      }
+      /**
+       * Capture information from a conversation turn.
+       * Processes a single message or turn of conversation.
+       */
+      async captureTurn(text, options) {
+        const source = {
+          conversationId: options.conversationId,
+          messageIds: options.messageIds ?? [],
+          timestamp: nowIso(),
+          turnIndex: 0
+        };
+        const instructions = detectExplicitInstructions(text, source);
+        const hasDoNotRemember = instructions.some((i2) => i2.type === "do-not-remember");
+        const hasExplicitRemember = instructions.some((i2) => i2.type === "remember");
+        let created = 0, linked = 0, ignored = 0;
+        if (hasDoNotRemember && !hasExplicitRemember) {
+          const item2 = {
+            id: generateId(),
+            category: "temporary_context",
+            statement: text,
+            content: { text },
+            entities: [],
+            relationships: [],
+            provenance: {
+              source,
+              classification: "temporary_context",
+              confidence: "low",
+              epistemicType: "observed",
+              capturedAt: nowIso(),
+              method: "automatic"
+            },
+            confidence: "low",
+            epistemicType: "observed"
+          };
+          await this.storeSessionContext(options.conversationId, [item2], instructions);
+          ignored++;
+          return { items: [item2], instructions, created: 0, linked: 0, ignored: 1, dedupMatches: [] };
+        }
+        const category = classifyCategory(text, instructions);
+        const epistemicType = determineEpistemicType(category, text, instructions);
+        const confidence = determineConfidence(category, epistemicType);
+        const entities = extractEntities(text);
+        const relationships = extractRelationships(text, entities);
+        const provenance = {
+          source,
+          classification: category,
+          confidence,
+          epistemicType,
+          capturedAt: nowIso(),
+          method: hasExplicitRemember ? "explicit" : "automatic"
+        };
+        const item = {
+          id: generateId(),
+          category,
+          statement: text,
+          content: { text },
+          entities,
+          relationships,
+          provenance,
+          confidence,
+          epistemicType
+        };
+        const sessionCtx = this.sessionContexts.get(options.conversationId);
+        const existingItems = sessionCtx ? sessionCtx.items : [];
+        const dedupMatches = await findExistingSimilarItems(
+          text,
+          category,
+          existingItems,
+          this.config.dedupSimilarityThreshold
+        );
+        const memoryMatches = await findExistingMemoryEntries(text, category);
+        const allMatches = [...dedupMatches, ...memoryMatches];
+        let decision = "create";
+        if (allMatches.length > 0) {
+          const exactMatch = allMatches.find((m) => m.matchType === "exact");
+          if (exactMatch) {
+            decision = "link";
+            linked++;
+          } else {
+            decision = "create";
+            created++;
+          }
+        } else {
+          created++;
+        }
+        const finalItem = { ...item };
+        const shouldStore = decision === "create" || decision === "link";
+        if (shouldStore) {
+          await routeToStorage(finalItem, this.adapters, this.config);
+        }
+        await this.storeSessionContext(options.conversationId, [finalItem], instructions);
+        return { items: [finalItem], instructions, created, linked, ignored, dedupMatches: allMatches };
+      }
+      /**
+       * Capture information from a full conversation (array of messages).
+       * Processes each message and returns aggregated results.
+       */
+      async captureConversation(messages, options) {
+        const allItems = [];
+        const allInstructions = [];
+        let created = 0, updated = 0, linked = 0, ignored = 0;
+        const allDedupMatches = [];
+        for (const [index, msg] of messages.entries()) {
+          const source = {
+            conversationId: options.conversationId,
+            messageIds: [msg.id ?? `msg-${index}`],
+            timestamp: msg.timestamp ?? nowIso(),
+            turnIndex: index
+          };
+          const instructions = detectExplicitInstructions(msg.content, source);
+          allInstructions.push(...instructions);
+          const hasDoNotRemember = instructions.some((i2) => i2.type === "do-not-remember");
+          const hasExplicitRemember = instructions.some((i2) => i2.type === "remember");
+          if (hasDoNotRemember && !hasExplicitRemember) {
+            const item2 = {
+              id: generateId(),
+              category: "temporary_context",
+              statement: msg.content,
+              content: { text: msg.content, role: msg.role },
+              entities: [],
+              relationships: [],
+              provenance: {
+                source,
+                classification: "temporary_context",
+                confidence: "low",
+                epistemicType: "observed",
+                capturedAt: nowIso(),
+                method: "automatic"
+              },
+              confidence: "low",
+              epistemicType: "observed"
+            };
+            allItems.push(item2);
+            ignored++;
+            continue;
+          }
+          const category = classifyCategory(msg.content, instructions);
+          const epistemicType = determineEpistemicType(category, msg.content, instructions);
+          const confidence = determineConfidence(category, epistemicType, msg.content);
+          const entities = extractEntities(msg.content);
+          const relationships = extractRelationships(msg.content, entities);
+          const provenance = {
+            source,
+            classification: category,
+            confidence,
+            epistemicType,
+            capturedAt: nowIso(),
+            method: hasExplicitRemember ? "explicit" : "automatic"
+          };
+          const item = {
+            id: generateId(),
+            category,
+            statement: msg.content,
+            content: { text: msg.content, role: msg.role },
+            entities,
+            relationships,
+            provenance,
+            confidence,
+            epistemicType
+          };
+          const dedupMatches = await findExistingSimilarItems(
+            msg.content,
+            category,
+            allItems,
+            this.config.dedupSimilarityThreshold
+          );
+          const memoryMatches = await findExistingMemoryEntries(msg.content, category);
+          const allMatches = [...dedupMatches, ...memoryMatches];
+          allDedupMatches.push(...allMatches);
+          let decision = "create";
+          if (allMatches.length > 0) {
+            const exactMatch = allMatches.find((m) => m.matchType === "exact");
+            if (exactMatch) {
+              decision = "link";
+              linked++;
+            } else {
+              decision = "create";
+              created++;
+            }
+          } else {
+            created++;
+          }
+          const shouldStore = decision === "create" || decision === "link";
+          if (shouldStore) {
+            await routeToStorage(item, this.adapters, this.config);
+          }
+          if (!shouldStore) ignored++;
+          allItems.push(item);
+        }
+        await this.storeSessionContext(options.conversationId, allItems, allInstructions);
+        return {
+          items: allItems,
+          created,
+          updated,
+          linked,
+          ignored,
+          dedupMatches: allDedupMatches,
+          provenance: allItems.map((i2) => i2.provenance)
+        };
+      }
+      /**
+       * Retrieve captured items for a conversation.
+       */
+      async getCapturedItems(conversationId) {
+        const ctx = this.sessionContexts.get(conversationId);
+        return ctx ? ctx.items : [];
+      }
+      /**
+       * Get all captured items across all conversations.
+       */
+      async getAllCapturedItems() {
+        const all = [];
+        for (const ctx of this.sessionContexts.values()) {
+          all.push(...ctx.items);
+        }
+        return all;
+      }
+      /**
+       * Clear session context (for testing / cleanup).
+       */
+      clearSession(conversationId) {
+        this.sessionContexts.delete(conversationId);
+      }
+      /**
+       * Get capture engine configuration.
+       */
+      getConfig() {
+        return { ...this.config };
+      }
+      // ---------------------------------------------------------------------------
+      // Private
+      // ---------------------------------------------------------------------------
+      async storeSessionContext(conversationId, items, instructions) {
+        let ctx = this.sessionContexts.get(conversationId);
+        if (!ctx) {
+          ctx = {
+            conversationId,
+            startedAt: nowIso(),
+            items: [],
+            explicitInstructions: []
+          };
+          this.sessionContexts.set(conversationId, ctx);
+        }
+        ctx.items.push(...items);
+        ctx.explicitInstructions.push(...instructions);
+        try {
+          const stateKey = `${CAPTURE_STATE_KEY}:${conversationId}`;
+          const existing = store.get(stateKey);
+          let prior = [];
+          if (existing) {
+            try {
+              prior = JSON.parse(existing);
+            } catch {
+            }
+          }
+          store.set(stateKey, JSON.stringify([...prior, ...items]));
+        } catch {
+        }
+      }
+    };
+    captureEngine = new CaptureEngine();
+    __name(captureConversation, "captureConversation");
+    __name(captureTurn, "captureTurn");
+  }
+});
 
 // core/memory/index.ts
 var memory_exports = {};
@@ -11259,6 +12140,7 @@ var init_memory = __esm({
     init_profile2();
     init_note();
     init_seed();
+    init_capture_engine();
     init_security();
     init_detection_events();
     init_detection_journal();
@@ -11369,7 +12251,7 @@ var init_memory = __esm({
        */
       async clear() {
         await entries.clearEntries();
-        store.remove("__dotmem_acquired_knowledge_state__");
+        store$1.remove("__dotmem_acquired_knowledge_state__");
         await resetKnowledgeRuntimeCaches();
         resetBrainPathCache();
         resetPolicyStoreCache();
@@ -11447,6 +12329,25 @@ var init_memory = __esm({
         async getSeedId() {
           return SEED_ID;
         }
+      },
+      /** Automatic conversational capture engine (Phase 2 — Workstream B). */
+      capture: {
+        engine: captureEngine,
+        async conversation(messages, options) {
+          return captureConversation(messages, options);
+        },
+        async turn(text, options) {
+          return captureTurn(text, options);
+        },
+        async getItems(conversationId) {
+          return captureEngine.getCapturedItems(conversationId);
+        },
+        async getAllItems() {
+          return captureEngine.getAllCapturedItems();
+        },
+        clearSession(conversationId) {
+          captureEngine.clearSession(conversationId);
+        }
       }
     };
   }
@@ -13324,7 +14225,7 @@ Storage and session:
 Utilities:
   codenames                    print reserved codenames
   render <view>                render a markdown view from the knowledge store
-  spark --verify               verify the dotmem-scintilla block in docs/AGENTS.md
+  spark --verify               verify the dotmem-scintilla block in specifications/AGENTS.md
   note <subcommand>            store and retrieve markdown files and text blocks (add|list|show|export|forget)
   seed <file|->                development-only: inject the Joy initial memory seed (JHF, requires \`--dev\`)
 
@@ -13361,13 +14262,13 @@ Examples:
   npx dotmem --version
 
 Learn more:
-  docs/AGENTS.md               AI working rules and the complete memory.* surface
-  docs/MEMORY.md               the memory reference
+  specifications/agents.md         AI working rules and the complete memory.* surface
+  specifications/memory.md         the memory reference
   npx dotmem policy contract acquire --json
                               the acquisition contract`;
 }
 __name(topLevelUsage, "topLevelUsage");
-function dispatch3(command, args) {
+function dispatch4(command, args) {
   if (!command) {
     void runContextCli("current project");
     return;
@@ -13736,7 +14637,7 @@ ids by keeping the newest copy (by acquiredAt) and retracting the shadowed one.
   console.info(topLevelUsage());
   process2.exit(1);
 }
-__name(dispatch3, "dispatch");
+__name(dispatch4, "dispatch");
 async function runCodenamesCli(args) {
   const json = args.includes("--json");
   if (json) {
@@ -14702,10 +15603,10 @@ async function runDoctorCli(args) {
     const policyStale = [];
     try {
       const { PolicyStore: PolicyStore2 } = await Promise.resolve().then(() => (init_policy_store(), policy_store_exports));
-      const store5 = new PolicyStore2();
+      const store6 = new PolicyStore2();
       for (const ns of ["operator", "security"]) {
         try {
-          const doc = await store5.load(ns);
+          const doc = await store6.load(ns);
           for (const record of doc.records) {
             if (record.condition && record.condition.kind === "payload-language") {
               policyStale.push({ namespace: ns, id: record.id, event: record.event, condition: JSON.stringify(record.condition) });
@@ -15536,4 +16437,4 @@ function inspectMemory(file) {
 }
 __name(inspectMemory, "inspectMemory");
 
-export { AUTHORITY_INCIDENT_TYPE, AUTHORITY_IS_RELATIONSHIP, BUILT_IN_TOOL_EVENTS, CANONICAL_BEHAVIORAL_INVARIANTS, CANONICAL_INVARIANT_IDS, CURRENT_AUTHORITY_REQUIRES_CURRENT_EVIDENCE, ContractOverlayError, DETECTION_EVENT_KINDS, DISCOVERY_PIPELINE_STAGES, DOTMEM_STORAGE_ROOT_ENV_VAR, DOTMEM_STORAGE_SETTINGS_FILE_NAME, DOTMEM_STORAGE_SETTINGS_VERSION, DotMemStorageLocationError, ENFORCEMENT_TIERS, EXPLANATION_DISPOSITIONS, EXPLANATION_REASONS, FEEDBACK_FILE_NAME, FEEDBACK_FORMAT_VERSION, HANDSHAKE_CAPABILITIES, HANDSHAKE_CHALLENGE, HANDSHAKE_VERSION, HISTORICAL_IDENTITY_NEVER_AUTHENTICATES, IDENTITY_COMPOSITION_NOT_FUSION, IDENTITY_STABLE_METADATA_SEPARATE, INCIDENT_FORBIDDEN_KEYS, IdentityGovernanceError, JO_PROFILE, LOOPS_FILE_NAME, LOOPS_FORMAT_VERSION, MAX_OVERRIDE_WINDOW_MS, MEMORY_ACQUIRE_EVENT, MEMORY_ACQUISITION_CONTRACT, MEMORY_PROJECTION_CONTRACT, MODEL_CARRIES_NOT_REDEFINES, POLICY_AUDIT_RETENTION, POLICY_LOCK_TTL_MS, POLICY_NAMESPACES, PolicyNamespaceLockError, PolicyStore, PolicyStoreError, RECOVERY_STEPS, REMEMBERING_IS_NOT_AUTHENTICATING, RENDER_FORMAT_VERSION, ROLE_MAP_FIELDS, SEED_ID, TIER_ENFORCEMENT, TOOL_EVENTS, UNAUTHORIZED_TRANSITIONS, VAULT_FILE_NAME, VAULT_FORMAT_VERSION, addLoop, assertNoConversationalOverride, authorityRelaxationPermitted, authorityRevocationPermitted, bootstrapProject, buildAuthorityIncident, buildHandshakeSessionRecord, buildPreHandshakeContract, buildTrustedRoleMap, calculateBudgetUsage, canonicalEvent, canonicalHash, canonicalPolicyFingerprint, canonicalSignature, canonicalStringify, checkHandshakeValidity, checkIdentityRenameAdmissibility, checkProjectState, clearDotMemStorageRootOverride, clearHandshakeSessionRecord, clearUserIdentity, closeLoop, computeContractRevision, computeCurrentRuntimeId, computeRuntimeId, constructEffectiveAgentContract, continuity, crossAcquisitionBoundary, describeCarrierHandshake, describeDotMemStorage, describeIdentityAndRuntime, detectAiEnvironment, detectAuthorityEscalationAttempt, detectAuthorityRoleDrift, detectBehaviorCoreMutationAttempt, detectIdentityFusion, detectIdentityMutationAttempt, detectPolicyBypassAttempt, detectSelfPromoted, detectUnauthorizedTransitions, detectUntrustedCurrentAssertion, discoverProjectSettingsFilePath, dispatch3 as dispatch, draftCorrectionExperience, encodeLogicSeed, ensureProjectAnchor, ensureUserDotMemInitialized, evaluateCarrierActivation, evaluateCarrierCompatibility, evaluateFreshness, evaluatePolicies, evaluateRoleActivation, explainBudgetAllocation, explainDiscovery, explainIdentityResolution, extractCarrierMapping, findIncidentForbiddenKey, formatBudgetExplanation, formatCheckResult, formatGuardResult, formatVerifyResult, getFeedbackForClaim, getFeedbackSummary, getLoop, getMemoryReadiness, initializeProject, injectJoySeed, inspectMem, inspectMemory, isDevSeedEnabled, isHiBound, listLoops, listViews, loadCanonicalBehavioralInvariants, loadHandshakeSessionRecord, loadIdentityGovernance, loadLoops, memory, mergeBehavioralInvariants, noteDotMemPackageInstallPath, parseContextArgs, parseHandshakeSessionRecord, parseLearnArgs, parseStorageRootFlag, preserveCanonicalIdentity, printAcquireUsage, printLearnUsage, printPolicyUsage, probeDotMemStorageCapabilities, projectAnchorExists, projectContractIdentity, readDotMemStorageLocator, readStdin, readStorageSettings, reconcileAuthorityState, reconstructCanonicalState, recordFeedback, redactTraceText, relocateDotMemStorage, renderAcquisitionContract, renderAgentRules, renderBootstrapReport, renderExplanation, renderHandshakeChallenge, renderMarkdownIndex, renderOperatorContract, renderReasoningTrace, renderView, resetCarrierHandshake, resolveAuthorityBinding, resolveDotMemStorageRoot, resolveEffectivePolicies, resolveEffectiveTier, resolveHandshakeSessionPath, resolveIdentity, resolveOverrideState, resolvePolicyNamespaceLockPath, resolveProjectIdentity, resolveProjectSettingsFilePath, resolveUserAgentMemoryPath, resolveUserAnchor, resolveUserBrainPath, resolveUserContractPath, resolveUserDotMemPath, resolveUserExperiencePath, resolveUserIdentity, resolveUserIdentityGovernancePath, resolveUserPolicyDir2 as resolveUserPolicyDir, resolveUserPolicyFilePath, resolveUserProjectMemoryPath, resolveUserReadmePath, resolveUserSettingsFilePath, restoreDefaultDotMemStorage, runAcquireCli, runAllClaimChecks, runAuthorityRecovery, runBootstrap, runCarrierHandshake, runClaimChecks, runCodenamesCli, runContext, runContextCli, runContinuityCli, runDoctorCli, runFeedbackCli, runGuardCli, runHandshakeCli, runLearnCli, runLoopCli, runNoteCli, runPolicyCli, runRenderCli, runRuleCli, runRulesCli, runSeedCli, runSessionCli, runSparkCli, runStorageCli, runVaultCli, runVerifyCli, runViolationCli, saveCorrectionDrafts, saveHandshakeSessionRecord, saveLoops, setDetectionEventSink, setDotMemStorageRootOverride, setIdentityGovernance, setUserIdentity, sha256Hex, sourceRef, suggestCorrectionPrompt, summarizeFeedbackWeights, summarizeToolPolicyDecision, topLevelUsage, validateBehavioralInvariantAdditions, validateContractOverlay, validateContractOverlays, validateFeedbackEntry, validateRetrospectiveClaim, vaultForget, vaultList, vaultPut, vaultResolve, verifyDueClaims, withPolicyNamespaceLock, withoutOverlays };
+export { AUTHORITY_INCIDENT_TYPE, AUTHORITY_IS_RELATIONSHIP, BUILT_IN_TOOL_EVENTS, CANONICAL_BEHAVIORAL_INVARIANTS, CANONICAL_INVARIANT_IDS, CURRENT_AUTHORITY_REQUIRES_CURRENT_EVIDENCE, ContractOverlayError, DETECTION_EVENT_KINDS, DISCOVERY_PIPELINE_STAGES, DOTMEM_STORAGE_ROOT_ENV_VAR, DOTMEM_STORAGE_SETTINGS_FILE_NAME, DOTMEM_STORAGE_SETTINGS_VERSION, DotMemStorageLocationError, ENFORCEMENT_TIERS, EXPLANATION_DISPOSITIONS, EXPLANATION_REASONS, FEEDBACK_FILE_NAME, FEEDBACK_FORMAT_VERSION, HANDSHAKE_CAPABILITIES, HANDSHAKE_CHALLENGE, HANDSHAKE_VERSION, HISTORICAL_IDENTITY_NEVER_AUTHENTICATES, IDENTITY_COMPOSITION_NOT_FUSION, IDENTITY_STABLE_METADATA_SEPARATE, INCIDENT_FORBIDDEN_KEYS, IdentityGovernanceError, JO_PROFILE, LOOPS_FILE_NAME, LOOPS_FORMAT_VERSION, MAX_OVERRIDE_WINDOW_MS, MEMORY_ACQUIRE_EVENT, MEMORY_ACQUISITION_CONTRACT, MEMORY_PROJECTION_CONTRACT, MODEL_CARRIES_NOT_REDEFINES, POLICY_AUDIT_RETENTION, POLICY_LOCK_TTL_MS, POLICY_NAMESPACES, PolicyNamespaceLockError, PolicyStore, PolicyStoreError, RECOVERY_STEPS, REMEMBERING_IS_NOT_AUTHENTICATING, RENDER_FORMAT_VERSION, ROLE_MAP_FIELDS, SEED_ID, TIER_ENFORCEMENT, TOOL_EVENTS, UNAUTHORIZED_TRANSITIONS, VAULT_FILE_NAME, VAULT_FORMAT_VERSION, addLoop, assertNoConversationalOverride, authorityRelaxationPermitted, authorityRevocationPermitted, bootstrapProject, buildAuthorityIncident, buildHandshakeSessionRecord, buildPreHandshakeContract, buildTrustedRoleMap, calculateBudgetUsage, canonicalEvent, canonicalHash, canonicalPolicyFingerprint, canonicalSignature, canonicalStringify, checkHandshakeValidity, checkIdentityRenameAdmissibility, checkProjectState, clearDotMemStorageRootOverride, clearHandshakeSessionRecord, clearUserIdentity, closeLoop, computeContractRevision, computeCurrentRuntimeId, computeRuntimeId, constructEffectiveAgentContract, continuity, crossAcquisitionBoundary, describeCarrierHandshake, describeDotMemStorage, describeIdentityAndRuntime, detectAiEnvironment, detectAuthorityEscalationAttempt, detectAuthorityRoleDrift, detectBehaviorCoreMutationAttempt, detectIdentityFusion, detectIdentityMutationAttempt, detectPolicyBypassAttempt, detectSelfPromoted, detectUnauthorizedTransitions, detectUntrustedCurrentAssertion, discoverProjectSettingsFilePath, dispatch4 as dispatch, draftCorrectionExperience, encodeLogicSeed, ensureProjectAnchor, ensureUserDotMemInitialized, evaluateCarrierActivation, evaluateCarrierCompatibility, evaluateFreshness, evaluatePolicies, evaluateRoleActivation, explainBudgetAllocation, explainDiscovery, explainIdentityResolution, extractCarrierMapping, findIncidentForbiddenKey, formatBudgetExplanation, formatCheckResult, formatGuardResult, formatVerifyResult, getFeedbackForClaim, getFeedbackSummary, getLoop, getMemoryReadiness, initializeProject, injectJoySeed, inspectMem, inspectMemory, isDevSeedEnabled, isHiBound, listLoops, listViews, loadCanonicalBehavioralInvariants, loadHandshakeSessionRecord, loadIdentityGovernance, loadLoops, memory, mergeBehavioralInvariants, noteDotMemPackageInstallPath, parseContextArgs, parseHandshakeSessionRecord, parseLearnArgs, parseStorageRootFlag, preserveCanonicalIdentity, printAcquireUsage, printLearnUsage, printPolicyUsage, probeDotMemStorageCapabilities, projectAnchorExists, projectContractIdentity, readDotMemStorageLocator, readStdin, readStorageSettings, reconcileAuthorityState, reconstructCanonicalState, recordFeedback, redactTraceText, relocateDotMemStorage, renderAcquisitionContract, renderAgentRules, renderBootstrapReport, renderExplanation, renderHandshakeChallenge, renderMarkdownIndex, renderOperatorContract, renderReasoningTrace, renderView, resetCarrierHandshake, resolveAuthorityBinding, resolveDotMemStorageRoot, resolveEffectivePolicies, resolveEffectiveTier, resolveHandshakeSessionPath, resolveIdentity, resolveOverrideState, resolvePolicyNamespaceLockPath, resolveProjectIdentity, resolveProjectSettingsFilePath, resolveUserAgentMemoryPath, resolveUserAnchor, resolveUserBrainPath, resolveUserContractPath, resolveUserDotMemPath, resolveUserExperiencePath, resolveUserIdentity, resolveUserIdentityGovernancePath, resolveUserPolicyDir2 as resolveUserPolicyDir, resolveUserPolicyFilePath, resolveUserProjectMemoryPath, resolveUserReadmePath, resolveUserSettingsFilePath, restoreDefaultDotMemStorage, runAcquireCli, runAllClaimChecks, runAuthorityRecovery, runBootstrap, runCarrierHandshake, runClaimChecks, runCodenamesCli, runContext, runContextCli, runContinuityCli, runDoctorCli, runFeedbackCli, runGuardCli, runHandshakeCli, runLearnCli, runLoopCli, runNoteCli, runPolicyCli, runRenderCli, runRuleCli, runRulesCli, runSeedCli, runSessionCli, runSparkCli, runStorageCli, runVaultCli, runVerifyCli, runViolationCli, saveCorrectionDrafts, saveHandshakeSessionRecord, saveLoops, setDetectionEventSink, setDotMemStorageRootOverride, setIdentityGovernance, setUserIdentity, sha256Hex, sourceRef, suggestCorrectionPrompt, summarizeFeedbackWeights, summarizeToolPolicyDecision, topLevelUsage, validateBehavioralInvariantAdditions, validateContractOverlay, validateContractOverlays, validateFeedbackEntry, validateRetrospectiveClaim, vaultForget, vaultList, vaultPut, vaultResolve, verifyDueClaims, withPolicyNamespaceLock, withoutOverlays };