dotmem 0.0.4 → 0.0.7

package/cli.cjs

@@ -6271,8 +6271,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) {
@@ -8697,6 +8697,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: {} };
 }
@@ -8761,9 +8774,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;
@@ -8823,10 +8880,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");
@@ -8849,6 +8910,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 {
@@ -8981,6 +9055,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;
@@ -9035,12 +9136,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");
   }
@@ -9732,27 +9836,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] : exports.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) => exports.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);
       },
       /**
@@ -9766,16 +9870,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 exports.evaluatePolicies({ event, claims, policies, overrides, payload });
@@ -9797,14 +9901,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;
         },
@@ -9812,8 +9916,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);
@@ -9826,8 +9930,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 exports.MEMORY_PROJECTION_CONTRACT;
@@ -11241,6 +11345,783 @@ var init_seed = __esm({
     }, "injectJoySeed");
   }
 });
+function generateId() {
+  return `capture-${memorio.hlc.serialize(memorio.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 {
+    }
+  }
+  memorio.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 = {};
@@ -11268,6 +12149,7 @@ var init_memory = __esm({
     init_profile2();
     init_note();
     init_seed();
+    init_capture_engine();
     init_security();
     init_detection_events();
     init_detection_journal();
@@ -11456,6 +12338,25 @@ var init_memory = __esm({
         async getSeedId() {
           return exports.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);
+        }
       }
     };
   }
@@ -13333,7 +14234,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\`)
 
@@ -13370,13 +14271,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;
@@ -13745,7 +14646,7 @@ ids by keeping the newest copy (by acquiredAt) and retracting the shadowed one.
   console.info(topLevelUsage());
   process2__default.default.exit(1);
 }
-__name(dispatch3, "dispatch");
+__name(dispatch4, "dispatch");
 async function runCodenamesCli(args) {
   const json = args.includes("--json");
   if (json) {
@@ -14711,10 +15612,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) });
@@ -15570,7 +16471,7 @@ exports.detectAiEnvironment = detectAiEnvironment;
 exports.detectAuthorityRoleDrift = detectAuthorityRoleDrift;
 exports.detectIdentityFusion = detectIdentityFusion;
 exports.detectUnauthorizedTransitions = detectUnauthorizedTransitions;
-exports.dispatch = dispatch3;
+exports.dispatch = dispatch4;
 exports.draftCorrectionExperience = draftCorrectionExperience;
 exports.encodeLogicSeed = encodeLogicSeed;
 exports.ensureProjectAnchor = ensureProjectAnchor;