dotmem 0.0.4 → 0.0.5

package/global.cjs

@@ -5061,13 +5061,13 @@ var init_mem_repository = __esm({
         });
       }
       async loadSources(sourceIds) {
-        const { readFile } = await nodeFs4();
+        const { readFile: readFile4 } = await nodeFs4();
         const ids = sourceIds ?? await this.discover();
         const sources = [];
         for (const sourceId of ids) {
           const filePath = memFilePath(this.directoryPath, sourceId);
           try {
-            const decoded = await parseMemFile(await readFile(filePath), sourceId);
+            const decoded = await parseMemFile(await readFile4(filePath), sourceId);
             sources.push({
               id: sourceId,
               filePath,
@@ -5151,10 +5151,10 @@ var init_mem_repository = __esm({
        * valid package, so the backup is always a version this library can read.
        */
       async keepLastValidVersion(filePath) {
-        const { readFile, copyFile, rename, rm } = await nodeFs4();
+        const { readFile: readFile4, copyFile, rename, rm } = await nodeFs4();
         let current;
         try {
-          current = await readFile(filePath);
+          current = await readFile4(filePath);
         } catch {
           return;
         }
@@ -5187,7 +5187,7 @@ var init_mem_repository = __esm({
         }
       }
       async writeSource(filePath, state3, preserved, preservedPackage) {
-        const { mkdir, rename, rm, open, readFile } = await nodeFs4();
+        const { mkdir, rename, rm, open, readFile: readFile4 } = await nodeFs4();
         if (!Number.isInteger(state3.version) || state3.version < 0) throw new Error("Invalid writable .mem knowledge version");
         for (const claim of state3.claims) validateClaim(claim);
         await mkdir(parentPath(filePath), { recursive: true });
@@ -5209,7 +5209,7 @@ var init_mem_repository = __esm({
           } finally {
             await handle.close();
           }
-          await decodeMemArtifact(await readFile(temporary));
+          await decodeMemArtifact(await readFile4(temporary));
           await this.keepLastValidVersion(filePath);
           for (let attempt = 0; attempt < 5; attempt++) {
             try {
@@ -5237,8 +5237,8 @@ var init_mem_repository = __esm({
 // core/knowledge/project-anchor.ts
 async function projectAnchorExists(projectId) {
   try {
-    const { readFile } = await import('fs/promises');
-    await readFile(resolveUserProjectMemoryPath(projectId));
+    const { readFile: readFile4 } = await import('fs/promises');
+    await readFile4(resolveUserProjectMemoryPath(projectId));
     return true;
   } catch {
     return false;
@@ -5274,7 +5274,7 @@ var init_project_anchor = __esm({
 var configureUserIdentityStore;
 var init_user_identity = __esm({
   "core/knowledge/user-identity.ts"() {
-    configureUserIdentityStore = /* @__PURE__ */ __name((store6) => {
+    configureUserIdentityStore = /* @__PURE__ */ __name((store7) => {
     }, "configureUserIdentityStore");
   }
 });
@@ -5878,9 +5878,155 @@ var init_staging = __esm({
 });
 
 // core/knowledge/loops.ts
+function joinPath3(base, child) {
+  const separator3 = process.platform === "win32" ? "\\" : "/";
+  return `${base.replace(/[\\/]+/g, separator3)}${separator3}${child}`;
+}
+function resolveLoopsFilePath() {
+  return joinPath3(resolveUserDotMemPath(), LOOPS_FILE_NAME);
+}
+async function readFile(path) {
+  try {
+    const fs = await import('fs/promises');
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile(path, content) {
+  const fs = await import('fs/promises');
+  const dir = path.replace(/[\\/][^\\/]+$/, "");
+  await fs.mkdir(dir, { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    await fs.writeFile(temporary, content, "utf8");
+    await fs.rename(temporary, path);
+  } catch {
+    await fs.rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error(`Failed to write loops file at ${path}`);
+  }
+}
+function emptyDocument() {
+  return { version: LOOPS_FORMAT_VERSION, loops: {} };
+}
+function validateDocument(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Loops document must be an object");
+  }
+  const document = value;
+  if (document.version !== LOOPS_FORMAT_VERSION) {
+    throw new Error(`Unsupported loops document version: ${String(document.version)}`);
+  }
+  if (!document.loops || typeof document.loops !== "object" || Array.isArray(document.loops)) {
+    throw new Error("Loops document loops must be an object");
+  }
+  const loops = {};
+  for (const [id, loopValue] of Object.entries(document.loops)) {
+    const loop = validateLoop(loopValue, id);
+    loops[loop.id] = loop;
+  }
+  return { version: LOOPS_FORMAT_VERSION, loops };
+}
+function validateLoop(value, id) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Loop ${id} must be an object`);
+  }
+  const loop = value;
+  if (typeof loop.id !== "string" || !loop.id) {
+    throw new Error(`Loop ${id} requires an id`);
+  }
+  if (typeof loop.text !== "string" || !loop.text) {
+    throw new Error(`Loop ${id} requires non-empty text`);
+  }
+  if (typeof loop.waitor !== "string" || !loop.waitor) {
+    throw new Error(`Loop ${id} requires a waitor`);
+  }
+  if (typeof loop.openedAt !== "string" || !loop.openedAt) {
+    throw new Error(`Loop ${id} requires an openedAt timestamp`);
+  }
+  const result = {
+    id: loop.id,
+    text: loop.text,
+    waitor: loop.waitor,
+    openedAt: loop.openedAt
+  };
+  if (typeof loop.closedAt === "string") result.closedAt = loop.closedAt;
+  if (typeof loop.closedBy === "string") result.closedBy = loop.closedBy;
+  if (typeof loop.closeNote === "string") result.closeNote = loop.closeNote;
+  return result;
+}
+async function loadLoops() {
+  const raw = await readFile(resolveLoopsFilePath());
+  if (!raw) return emptyDocument();
+  try {
+    return validateDocument(JSON.parse(raw));
+  } catch {
+    return emptyDocument();
+  }
+}
+async function saveLoops(document) {
+  await writeFile(resolveLoopsFilePath(), JSON.stringify(document, null, 2) + "\n");
+}
+async function addLoop(input) {
+  const document = await loadLoops();
+  if (document.loops[input.id]) {
+    throw new Error(`Loop ${input.id} already exists`);
+  }
+  const loop = {
+    id: input.id,
+    text: input.text,
+    waitor: input.waitor,
+    openedAt: input.openedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  document.loops[loop.id] = loop;
+  await saveLoops(document);
+  return loop;
+}
+async function listLoops(openOnly = true) {
+  const document = await loadLoops();
+  const all = Object.values(document.loops);
+  if (openOnly) {
+    return all.filter((loop) => loop.closedAt === void 0);
+  }
+  return all;
+}
+async function closeLoop(id, input) {
+  const document = await loadLoops();
+  const existing = document.loops[id];
+  if (!existing) {
+    throw new Error(`Loop ${id} not found`);
+  }
+  if (existing.closedAt) {
+    throw new Error(`Loop ${id} is already closed`);
+  }
+  const closed = {
+    ...existing,
+    closedAt: input.closedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    closedBy: input.by,
+    ...input.note ? { closeNote: input.note } : {}
+  };
+  document.loops[id] = closed;
+  await saveLoops(document);
+  return closed;
+}
+var LOOPS_FILE_NAME, LOOPS_FORMAT_VERSION;
 var init_loops = __esm({
   "core/knowledge/loops.ts"() {
     init_user_paths();
+    LOOPS_FILE_NAME = "loops.json";
+    LOOPS_FORMAT_VERSION = 1;
+    __name(joinPath3, "joinPath");
+    __name(resolveLoopsFilePath, "resolveLoopsFilePath");
+    __name(readFile, "readFile");
+    __name(writeFile, "writeFile");
+    __name(emptyDocument, "emptyDocument");
+    __name(validateDocument, "validateDocument");
+    __name(validateLoop, "validateLoop");
+    __name(loadLoops, "loadLoops");
+    __name(saveLoops, "saveLoops");
+    __name(addLoop, "addLoop");
+    __name(listLoops, "listLoops");
+    __name(closeLoop, "closeLoop");
   }
 });
 
@@ -5965,16 +6111,368 @@ var init_session = __esm({
 });
 
 // core/knowledge/exemplars.ts
+function joinPath4(base, child) {
+  const separator3 = process.platform === "win32" ? "\\" : "/";
+  return `${base.replace(/[\\/]+/g, separator3)}${separator3}${child}`;
+}
+function resolveExemplarsPath() {
+  return joinPath4(resolveUserDotMemPath(), EXEMPLARS_FILE_NAME);
+}
+async function readFile2(path) {
+  try {
+    const fs = await import('fs/promises');
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile2(path, content) {
+  const fs = await import('fs/promises');
+  const dir = path.replace(/[\\/][^\\/]+$/, "");
+  await fs.mkdir(dir, { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    await fs.writeFile(temporary, content, "utf8");
+    await fs.rename(temporary, path);
+  } catch {
+    await fs.rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error(`Failed to write exemplars file at ${path}`);
+  }
+}
+function emptyStore() {
+  return { version: EXEMPLARS_FORMAT_VERSION, exemplars: {} };
+}
+function validateExemplar(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Exemplar must be an object");
+  }
+  const e = value;
+  if (typeof e.id !== "string" || !e.id) throw new Error("Exemplar requires non-empty id");
+  if (typeof e.pattern !== "string" || !e.pattern) {
+    throw new Error(`Exemplar ${e.id} requires non-empty pattern`);
+  }
+  const source = e.source ?? {};
+  if (typeof source.conversationId !== "string" || !source.conversationId) {
+    throw new Error(`Exemplar ${e.id} requires source.conversationId`);
+  }
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: e.id,
+    type: "interaction-exemplar",
+    source: {
+      conversationId: source.conversationId,
+      messageIds: Array.isArray(source.messageIds) ? source.messageIds.map(String) : [],
+      ...typeof source.timestamp === "string" ? { timestamp: source.timestamp } : {}
+    },
+    pattern: e.pattern,
+    originalContent: typeof e.originalContent === "string" ? e.originalContent : null,
+    sourceReference: typeof e.sourceReference === "string" ? e.sourceReference : null,
+    retrievalHints: Array.isArray(e.retrievalHints) ? e.retrievalHints.map(String) : [],
+    significance: typeof e.significance === "number" && e.significance >= 0 ? e.significance : 0,
+    confidence: typeof e.confidence === "number" && e.confidence >= 0 && e.confidence <= 1 ? e.confidence : 0,
+    provenance: ["human-stated", "observed", "inferred"].includes(
+      e.provenance
+    ) ? e.provenance : "observed",
+    createdAt: typeof e.createdAt === "string" ? e.createdAt : now2,
+    revision: typeof e.revision === "number" && e.revision > 0 ? e.revision : 1
+  };
+}
+function validateStore(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Exemplars document must be an object");
+  }
+  const doc = value;
+  if (doc.version !== EXEMPLARS_FORMAT_VERSION) {
+    throw new Error(`Unsupported exemplars version: ${String(doc.version)}`);
+  }
+  const exemplars = {};
+  if (doc.exemplars && typeof doc.exemplars === "object" && !Array.isArray(doc.exemplars)) {
+    for (const [_, exemplarValue] of Object.entries(doc.exemplars)) {
+      const exemplar = validateExemplar(exemplarValue);
+      exemplars[exemplar.id] = exemplar;
+    }
+  }
+  return { version: EXEMPLARS_FORMAT_VERSION, exemplars };
+}
+async function loadExemplars() {
+  const raw = await readFile2(resolveExemplarsPath());
+  if (raw === null) return emptyStore();
+  try {
+    return validateStore(JSON.parse(raw));
+  } catch {
+    return emptyStore();
+  }
+}
+async function saveExemplars(store7) {
+  const validated = validateStore(store7);
+  await writeFile2(resolveExemplarsPath(), JSON.stringify(validated, null, 2));
+}
+async function addExemplar(exemplar) {
+  const store7 = await loadExemplars();
+  if (store7.exemplars[exemplar.id]) {
+    throw new Error(`Exemplar ${exemplar.id} already exists`);
+  }
+  if (exemplar.sourceReference) {
+    const existingRef = Object.values(store7.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
+  };
+  store7.exemplars[exemplar.id] = full;
+  await saveExemplars(store7);
+  return full;
+}
+async function updateExemplar(id, updates) {
+  const store7 = await loadExemplars();
+  const existing = store7.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
+  };
+  store7.exemplars[id] = updated;
+  await saveExemplars(store7);
+  return updated;
+}
+var EXEMPLARS_FILE_NAME, EXEMPLARS_FORMAT_VERSION;
 var init_exemplars = __esm({
   "core/knowledge/exemplars.ts"() {
     init_user_paths();
+    EXEMPLARS_FILE_NAME = "exemplars.json";
+    EXEMPLARS_FORMAT_VERSION = 1;
+    __name(joinPath4, "joinPath");
+    __name(resolveExemplarsPath, "resolveExemplarsPath");
+    __name(readFile2, "readFile");
+    __name(writeFile2, "writeFile");
+    __name(emptyStore, "emptyStore");
+    __name(validateExemplar, "validateExemplar");
+    __name(validateStore, "validateStore");
+    __name(loadExemplars, "loadExemplars");
+    __name(saveExemplars, "saveExemplars");
+    __name(addExemplar, "addExemplar");
+    __name(updateExemplar, "updateExemplar");
   }
 });
 
 // core/knowledge/personality-anchor.ts
+function joinPath5(base, child) {
+  const separator3 = process.platform === "win32" ? "\\" : "/";
+  return `${base.replace(/[\\/]+/g, separator3)}${separator3}${child}`;
+}
+function resolvePersonalityAnchorPath() {
+  return joinPath5(resolveUserDotMemPath(), PERSONALITY_ANCHOR_FILE_NAME);
+}
+async function readFile3(path) {
+  try {
+    const fs = await import('fs/promises');
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile3(path, content) {
+  const fs = await import('fs/promises');
+  const dir = path.replace(/[\\/][^\\/]+$/, "");
+  await fs.mkdir(dir, { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    await fs.writeFile(temporary, content, "utf8");
+    await fs.rename(temporary, path);
+  } catch {
+    await fs.rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error(`Failed to write personality anchor at ${path}`);
+  }
+}
+function emptyAnchor() {
+  const epoch = "1970-01-01T00:00:00.000Z";
+  return {
+    version: PERSONALITY_ANCHOR_FORMAT_VERSION,
+    identity: {
+      communicationStyle: [],
+      durablePreferences: [],
+      interactionBoundaries: []
+    },
+    metadata: {
+      createdAt: epoch,
+      updatedAt: epoch,
+      revision: 1,
+      sourceReferences: []
+    }
+  };
+}
+function validateCommunicationStyle(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("communicationStyle entry must be an object");
+  }
+  const style = value;
+  if (typeof style.description !== "string" || !style.description) {
+    throw new Error("communicationStyle entry requires non-empty description");
+  }
+  const confidence = style.confidence ?? "inferred";
+  if (!["inferred", "observed", "human-stated"].includes(confidence)) {
+    throw new Error(`Invalid confidence value: ${String(style.confidence)}`);
+  }
+  const evidence = Array.isArray(style.evidence) ? style.evidence.map(String) : [];
+  return {
+    description: style.description,
+    confidence,
+    evidence,
+    lastObserved: typeof style.lastObserved === "string" ? style.lastObserved : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function validateDurablePreference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("durablePreference entry must be an object");
+  }
+  const pref = value;
+  if (typeof pref.id !== "string" || !pref.id) {
+    throw new Error("durablePreference entry requires non-empty id");
+  }
+  if (typeof pref.statement !== "string" || !pref.statement) {
+    throw new Error(`durablePreference ${pref.id} requires non-empty statement`);
+  }
+  const confidence = pref.confidence ?? "inferred";
+  if (!["inferred", "observed", "human-stated"].includes(confidence)) {
+    throw new Error(`Invalid confidence value: ${String(pref.confidence)}`);
+  }
+  const evidence = Array.isArray(pref.evidence) ? pref.evidence.map(String) : [];
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: pref.id,
+    statement: pref.statement,
+    confidence,
+    evidence,
+    firstObserved: typeof pref.firstObserved === "string" ? pref.firstObserved : now2,
+    lastConfirmed: typeof pref.lastConfirmed === "string" ? pref.lastConfirmed : now2,
+    ...typeof pref.supersededBy === "string" ? { supersededBy: pref.supersededBy } : {}
+  };
+}
+function validateInteractionBoundary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("interactionBoundary entry must be an object");
+  }
+  const boundary = value;
+  if (typeof boundary.id !== "string" || !boundary.id) {
+    throw new Error("interactionBoundary entry requires non-empty id");
+  }
+  if (typeof boundary.rule !== "string" || !boundary.rule) {
+    throw new Error(`interactionBoundary ${boundary.id} requires non-empty rule`);
+  }
+  const confidence = boundary.confidence ?? "inferred";
+  if (!["inferred", "observed", "human-stated"].includes(confidence)) {
+    throw new Error(`Invalid confidence value: ${String(boundary.confidence)}`);
+  }
+  const evidence = Array.isArray(boundary.evidence) ? boundary.evidence.map(String) : [];
+  const source = boundary.source ?? "conversation";
+  if (!["profile", "memory", "conversation"].includes(source)) {
+    throw new Error(`Invalid boundary source: ${String(boundary.source)}`);
+  }
+  return {
+    id: boundary.id,
+    rule: boundary.rule,
+    confidence,
+    evidence,
+    source,
+    lastConfirmed: typeof boundary.lastConfirmed === "string" ? boundary.lastConfirmed : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function validateAnchor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Personality anchor document must be an object");
+  }
+  const doc = value;
+  if (doc.version !== PERSONALITY_ANCHOR_FORMAT_VERSION) {
+    throw new Error(`Unsupported personality anchor version: ${String(doc.version)}`);
+  }
+  const identity = doc.identity ?? {};
+  const metadata = doc.metadata ?? {};
+  const communicationStyle = Array.isArray(identity.communicationStyle) ? identity.communicationStyle.map(validateCommunicationStyle) : [];
+  const durablePreferences = Array.isArray(identity.durablePreferences) ? identity.durablePreferences.map(validateDurablePreference) : [];
+  const interactionBoundaries = Array.isArray(identity.interactionBoundaries) ? identity.interactionBoundaries.map(validateInteractionBoundary) : [];
+  const sourceRefs = Array.isArray(metadata.sourceReferences) ? metadata.sourceReferences.map(String) : [];
+  return {
+    version: PERSONALITY_ANCHOR_FORMAT_VERSION,
+    identity: {
+      communicationStyle,
+      durablePreferences,
+      interactionBoundaries
+    },
+    metadata: {
+      createdAt: typeof metadata.createdAt === "string" ? metadata.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: typeof metadata.updatedAt === "string" ? metadata.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      revision: typeof metadata.revision === "number" && metadata.revision > 0 ? metadata.revision : 1,
+      sourceReferences: sourceRefs
+    }
+  };
+}
+async function loadPersonalityAnchor() {
+  const raw = await readFile3(resolvePersonalityAnchorPath());
+  if (raw === null) return emptyAnchor();
+  try {
+    const parsed = JSON.parse(raw);
+    return validateAnchor(parsed);
+  } catch {
+    return emptyAnchor();
+  }
+}
+async function savePersonalityAnchor(anchor) {
+  const validated = validateAnchor(anchor);
+  const dirPath = resolveUserDotMemPath();
+  const fs = await import('fs/promises');
+  await fs.mkdir(dirPath, { recursive: true });
+  await writeFile3(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;
+}
+var PERSONALITY_ANCHOR_FILE_NAME, PERSONALITY_ANCHOR_FORMAT_VERSION;
 var init_personality_anchor = __esm({
   "core/knowledge/personality-anchor.ts"() {
     init_user_paths();
+    PERSONALITY_ANCHOR_FILE_NAME = "personality-anchor.json";
+    PERSONALITY_ANCHOR_FORMAT_VERSION = 1;
+    __name(joinPath5, "joinPath");
+    __name(resolvePersonalityAnchorPath, "resolvePersonalityAnchorPath");
+    __name(readFile3, "readFile");
+    __name(writeFile3, "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");
   }
 });
 
@@ -7067,27 +7565,27 @@ var auditPolicyAction = /* @__PURE__ */ __name((action, key) => {
   }
 }, "auditPolicyAction");
 var resolveOverrides = /* @__PURE__ */ __name(async (namespace2, now2 = () => /* @__PURE__ */ new Date()) => {
-  const store6 = await getPolicyStore();
+  const store7 = await getPolicyStore();
   const namespaces = namespace2 ? [namespace2] : POLICY_NAMESPACES;
-  const documents = await Promise.all(namespaces.map((entry) => store6.load(entry)));
+  const documents = await Promise.all(namespaces.map((entry) => store7.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");
 var policy = {
   async assign(input, namespace2 = "operator", basedOnRevision) {
-    const store6 = await getPolicyStore();
-    const record = await store6.assign(input, namespace2, basedOnRevision);
+    const store7 = await getPolicyStore();
+    const record = await store7.assign(input, namespace2, basedOnRevision);
     auditPolicyAction("policy.assign", record.id);
     return record;
   },
   async list() {
-    const store6 = await getPolicyStore();
-    return store6.list();
+    const store7 = await getPolicyStore();
+    return store7.list();
   },
   async remove(id, namespace2 = "operator", basedOnRevision) {
-    const store6 = await getPolicyStore();
-    await store6.remove(id, namespace2, basedOnRevision);
+    const store7 = await getPolicyStore();
+    await store7.remove(id, namespace2, basedOnRevision);
     auditPolicyAction("policy.remove", id);
   },
   /**
@@ -7101,16 +7599,16 @@ var policy = {
    * the durable audit trail with a terminal CLEAR entry.
    */
   async clear(authority) {
-    const store6 = await getPolicyStore();
-    await store6.clear(authority);
+    const store7 = await getPolicyStore();
+    await store7.clear(authority);
     auditPolicyAction("policy.clear", "policy");
   },
   async evaluate(event, payload) {
-    const store6 = await getPolicyStore();
+    const store7 = await getPolicyStore();
     const [state3, policies, overrides] = await Promise.all([
       loadCombinedKnowledgeState(),
-      store6.list(),
-      store6.listOverrides()
+      store7.list(),
+      store7.listOverrides()
     ]);
     const claims = activeClaims(state3);
     return evaluatePolicies({ event, claims, policies, overrides, payload });
@@ -7132,14 +7630,14 @@ var policy = {
    */
   override: {
     async grant(input, namespace2 = "operator", basedOnRevision) {
-      const store6 = await getPolicyStore();
-      const override = await store6.grantOverride(input, namespace2, basedOnRevision);
+      const store7 = await getPolicyStore();
+      const override = await store7.grantOverride(input, namespace2, basedOnRevision);
       auditPolicyAction("policy.override", override.id);
       return override;
     },
     async revoke(input, namespace2 = "operator", basedOnRevision) {
-      const store6 = await getPolicyStore();
-      const override = await store6.revokeOverride(input, namespace2, basedOnRevision);
+      const store7 = await getPolicyStore();
+      const override = await store7.revokeOverride(input, namespace2, basedOnRevision);
       auditPolicyAction("policy.revoke", override.id);
       return override;
     },
@@ -7147,8 +7645,8 @@ var policy = {
       return resolveOverrides(namespace2);
     },
     async effective(event, namespace2) {
-      const store6 = await getPolicyStore();
-      const states = await store6.effectiveState(namespace2);
+      const store7 = await getPolicyStore();
+      const states = await store7.effectiveState(namespace2);
       if (event === void 0) return states;
       const canonical = event.trim();
       return states.filter((state3) => state3.event === canonical);
@@ -7161,8 +7659,8 @@ var policy = {
    * additional best-effort sink, and this is the durable record.
    */
   async audit(namespace2) {
-    const store6 = await getPolicyStore();
-    return store6.auditTrail(namespace2);
+    const store7 = await getPolicyStore();
+    return store7.auditTrail(namespace2);
   },
   contract() {
     return MEMORY_PROJECTION_CONTRACT;
@@ -8136,6 +8634,778 @@ var injectJoySeed = /* @__PURE__ */ __name(async (opts) => {
   return { id: seedId, action: "stored" };
 }, "injectJoySeed");
 
+// core/memory/capture-engine.ts
+init_exemplars();
+init_loops();
+init_personality_anchor();
+var CAPTURE_STATE_KEY = "__dotmem_capture_state__";
+var DEFAULT_CONFIG = {
+  minSignificance: 0.3,
+  maxItemsPerConversation: 50,
+  dedupSimilarityThreshold: 0.75,
+  preserveConflicts: true,
+  tempContextTtlMs: 24 * 60 * 60 * 1e3,
+  autoCreateExemplars: true,
+  autoCreateLoops: true,
+  autoCreateClaims: true
+};
+var 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"
+  ]
+};
+var 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
+];
+var 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
+];
+function generateId() {
+  return `capture-${memorio.hlc.serialize(memorio.hlc.tick())}-${Math.random().toString(36).slice(2, 10)}`;
+}
+__name(generateId, "generateId");
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+__name(nowIso, "nowIso");
+function normalizeText(text) {
+  return text.normalize("NFKC").toLocaleLowerCase("en-US").replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+__name(normalizeText, "normalizeText");
+function tokenize(text) {
+  return new Set(normalizeText(text).split(" ").filter((t) => t.length > 2));
+}
+__name(tokenize, "tokenize");
+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;
+}
+__name(jaccardSimilarity, "jaccardSimilarity");
+function containsPhrase2(text, phrase) {
+  const t = normalizeText(text);
+  const p = normalizeText(phrase);
+  return t.includes(p);
+}
+__name(containsPhrase2, "containsPhrase");
+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;
+}
+__name(detectExplicitInstructions, "detectExplicitInstructions");
+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;
+}
+__name(classifyCategory, "classifyCategory");
+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";
+}
+__name(determineEpistemicType, "determineEpistemicType");
+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";
+}
+__name(determineConfidence, "determineConfidence");
+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;
+}
+__name(extractEntities, "extractEntities");
+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;
+}
+__name(extractRelationships, "extractRelationships");
+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;
+}
+__name(findExistingSimilarItems, "findExistingSimilarItems");
+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;
+}
+__name(findExistingMemoryEntries, "findExistingMemoryEntries");
+function shouldStoreInCoreMemory(category, epistemicType) {
+  return category === "preference" && epistemicType === "human-stated";
+}
+__name(shouldStoreInCoreMemory, "shouldStoreInCoreMemory");
+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 }
+  });
+}
+__name(routeToStorage, "routeToStorage");
+var 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 {
+    }
+  }
+};
+var captureEngine = new CaptureEngine();
+async function captureConversation(messages, options) {
+  return captureEngine.captureConversation(messages, options);
+}
+__name(captureConversation, "captureConversation");
+async function captureTurn(text, options) {
+  return captureEngine.captureTurn(text, options);
+}
+__name(captureTurn, "captureTurn");
+
 // core/memory/index.ts
 init_detection_events();
 init_detection_journal();
@@ -8323,6 +9593,25 @@ var memory = {
     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);
+    }
   }
 };