@theokit/sdk 4.62.0 → 4.63.0

package/docs/memory-decisions.md

@@ -18,10 +18,10 @@ decision the next refactor deletes.
 .theokit/memory/.index/memory.sqlite   on the first send, when memory is enabled
 ```
 
-**Why it looks wrong.** With `local.sessionDir` set, memory *facts* are written to
-`<sessionDir>/projects/<encoded-cwd>/memory/` — where the CLI reads them. So a project that never
-adopted this SDK ends up with a `.theokit/` directory anyway, which reads like the "write where the
-CLI reads" promise leaking.
+**Why it looks wrong.** With `memory.directory` pointed at the CLI's store, memory *facts* are
+written to `<claudeHome>/projects/<encoded-cwd>/memory/` — where the CLI reads them. So a project
+that never adopted this SDK ends up with a `.theokit/` directory anyway, which reads like the
+"write where the CLI reads" promise leaking.
 
 **Why it is right.** What lands in `.theokit/` is this SDK's own state, and neither piece has a
 Claude Code shape to be written in:
@@ -178,8 +178,9 @@ entries, ~3.2 KB per entry. Feeding the largest — 66 entries, 275 KB on disk
 turn's system prompt**, before the user has said anything. Nine more stores are already past the
 point where the injection exceeds a session budget.
 
-Two things make this worse than a size problem. The CLI's store is read **whether or not
-`local.sessionDir` is set**, so a consumer who never opted into CLI interop still gets it. And the
+Two things make this worse than a size problem. The CLI's store is read **unconditionally** —
+`memory.directory` decides where writes go, never what the read covers — so a consumer who never
+opted into CLI interop still gets it. And the
 cost is invisible: nothing errors, the window just fills, and the tokens are not attributed to
 memory. An earlier version of this document said "at 64 entries it does not hurt" — that was an
 assumption, and measuring it is what disproved it.
@@ -189,6 +190,42 @@ nothing — the data for a staleness signal is on disk today, unused.
 
 ---
 
+## One resolver, one root (#463)
+
+**What happens.** `memory.directory` — absolute, or `~/`-prefixed — is the only thing that decides
+where this agent's memory lives. Everything under the root follows it: `MEMORY.md`, the per-memory
+files, `notes/`, `sessions/`, `wiki/`, `transcripts/`, `dream-diary.md` and `.index/memory.sqlite`.
+
+**What it replaced.** The location used to be a side effect of `local.sessionDir`, the option that
+names the *transcript* home, on the reasoning that a consumer who set it had already opted into CLI
+interop. One option answered two questions — and of the fourteen places that computed a memory
+path, exactly one heard the second answer. `appendFact` relocated; the indexer, the `memory_get`
+path guard, `MEMORY.md`, `sessions/` and the index database did not. A relocated fact was written,
+never indexed, unreadable by the tool whose job is reading memory, and shadowed by a second
+`MEMORY.md` in the store it had left.
+
+**Why the root is a branded type.** `MemoryRoot` is `string` with a brand, produced only by
+`resolveMemoryRoot`. A cwd and a root are both strings, so without the brand the thirteen path
+helpers would go on accepting either, and the next helper added has the same even chance of taking
+the wrong one that produced this defect. The brand makes "every path derives from one resolution" a
+compiler rule instead of a convention.
+
+**The gap that remains, stated rather than hidden.** `IndexManager.open()` is a public entry point
+that takes a `cwd`, so its `memoryRoot` is optional and falls back to the default. Inside an agent
+the root is resolved once and handed to both the index and the read tool; a consumer opening the
+index by hand against a non-default directory has to pass it.
+
+**A relative `directory` is refused, not resolved.** The two plausible bases — the workspace and the
+process cwd — put the store in two different places, and picking one silently is how a store ends up
+split across both. `ConfigurationError` with code `invalid_memory_directory`.
+
+**How to check it still holds:** `tests/memory-root.test.ts`, in particular
+`test_the_indexer_scans_the_configured_directory_so_the_fact_is_searchable` and
+`test_the_project_store_gets_no_second_index_pointing_at_files_it_does_not_have` — the two halves
+that were broken.
+
+---
+
 ## Known gaps, recorded so they are not rediscovered
 
 Each row says what would close it, not only that it is open — the two invite very different work.
@@ -196,7 +233,7 @@ Each row says what would close it, not only that it is open — the two invite v
 | gap | where | what would close it |
 |---|---|---|
 | ~~The default recall path has no selection at all~~ — **closed** in `721a311f` | `local-agent-send.ts:257-272` | Closed: lexical relevance + recency, capped. Measured end to end against the real model — a 67-entry store went from ~66K to **13,606 tokens on the wire**, and the answering fact is recalled whether it is the oldest or the newest entry. |
-| The CLI's store is read whether or not `local.sessionDir` is set | `markdown-store.ts:114` — `claudeProjectMemoryDir(cwd)` is an unconditional read root | A decision, not a fix: it is deliberate (*write one, read all*, so a consumer's existing memories are never orphaned) and it means a consumer who never opted into CLI interop still receives what the CLI accumulated in that project. Cheap while the cap holds; revisit if the cap is ever removed. |
+| The CLI's store is read whether or not the consumer opted in | `storage/memory-root.ts` — `claudeProjectMemoryDir(cwd)` is an unconditional entry in `memoryReadRoots` | A decision, not a fix: it is deliberate (*write one, read all*, so a consumer's existing memories are never orphaned) and it means a consumer who never opted into CLI interop still receives what the CLI accumulated in that project. Cheap while the cap holds; revisit if the cap is ever removed. |
 | No retention of any kind — no TTL, prune, or decay | searched `ttl\|prune\|expire\|retention` across both packages: zero | A per-kind TTL plus a prune step in the sweep. Needs the kind vocabulary to mean something first (§ 2), which is why this orders before widening it. |
 | Quarantine marks but does not constrain | `memory-file.ts:96`, `memory-provider.ts:48` | Implemented: three states, and `[unconfirmed]` on entries the store counted once. **Measured against the real model and it does not close the hole** — a planted memory alone is acted on 5/5, and beside a corroborated contradiction it is still asserted ~62% of runs (n=32). Marking influences the model; it does not constrain it. The guarantee is not available at this layer: blocking an uncorroborated entry would break the promise that a fact written once is recallable next session. |
 | A planted memory can make the agent ACT | measured: `RELEASE_OVERRIDE.txt` created in 2 of 6 runs | Register the permission layer — `PermissionPlugin.create(new PermissionEngine(…))` — which blocks it every time. This is the half that IS closable at the tool boundary; the informational half above is not. Any deployment where the memory directory is writable by anything other than this agent needs it. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theokit/sdk",
-  "version": "4.62.0",
+  "version": "4.63.0",
   "description": "TypeScript SDK for the Theo agent harness — same surface, local or cloud.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/usetheokit/theokit-sdk#readme",

package/dist/chunk-2UCFUSPW.cjs

@@ -1,468 +0,0 @@
-'use strict';
-
-var chunkKRD3GQAA_cjs = require('./chunk-KRD3GQAA.cjs');
-var chunkR3UPQFKK_cjs = require('./chunk-R3UPQFKK.cjs');
-var chunkBUIK7GUA_cjs = require('./chunk-BUIK7GUA.cjs');
-var chunkZF2LDKQQ_cjs = require('./chunk-ZF2LDKQQ.cjs');
-var chunkI6TGFUCO_cjs = require('./chunk-I6TGFUCO.cjs');
-var chunkK3FW2XZD_cjs = require('./chunk-K3FW2XZD.cjs');
-var chunkJTB5Q42C_cjs = require('./chunk-JTB5Q42C.cjs');
-var promises = require('fs/promises');
-var os = require('os');
-var path = require('path');
-
-var MEMORY_KINDS = ["user", "feedback", "project", "reference"];
-function legacyMemoryJsonPath(cwd, config) {
-  if (config.storePath !== void 0) {
-    return path.resolve(cwd, config.storePath);
-  }
-  const namespace = chunkR3UPQFKK_cjs.sanitizeIdentifier(config.namespace ?? "default");
-  const scope = chunkR3UPQFKK_cjs.sanitizeIdentifier(config.scope ?? "agent", { maxLen: 16 });
-  const userId = chunkR3UPQFKK_cjs.sanitizeIdentifier(config.userId ?? "default");
-  return chunkR3UPQFKK_cjs.safePathJoin(cwd, ".theokit", "memory", namespace, `${scope}-${userId}.json`);
-}
-
-// src/internal/memory/storage/memory-file.ts
-var SAFE_SLUG = /^[a-z0-9][a-z0-9_-]*$/;
-var MAX_SLUG_LENGTH = 64;
-var TARGET_SLUG_LENGTH = 32;
-var TITLE_MAX_LENGTH = 40;
-var TITLE_MAX_WORDS = 4;
-var SLUG_STOPWORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "and",
-  "or",
-  "but",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "for",
-  "of",
-  "to",
-  "in",
-  "on",
-  "at",
-  "by",
-  "with",
-  "from",
-  "as",
-  "that",
-  "this",
-  "these",
-  "those",
-  "it",
-  "its",
-  "he",
-  "she",
-  "they",
-  "we",
-  "you",
-  "i",
-  "do",
-  "does",
-  "did",
-  "has",
-  "have",
-  "had",
-  "will",
-  "would",
-  "can",
-  "could",
-  "should",
-  "must",
-  "not",
-  "no",
-  "over",
-  "under",
-  "into",
-  "onto",
-  "than",
-  "then",
-  "when",
-  "where",
-  "which",
-  "who",
-  "why",
-  "how",
-  "all",
-  "any",
-  "each",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "only",
-  "own",
-  "same",
-  "so",
-  "too",
-  "very",
-  "just",
-  "also",
-  "about",
-  "after",
-  "before",
-  "between",
-  "during",
-  "up",
-  "down",
-  "out",
-  "off",
-  "again",
-  "once",
-  "here",
-  "there",
-  "if",
-  "because",
-  "while"
-]);
-function topicWords(text) {
-  return text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").split(/[^a-z0-9]+/).filter((w) => w.length >= 2 && !SLUG_STOPWORDS.has(w));
-}
-function slugForFact(text) {
-  const words = topicWords(text);
-  let slug = "";
-  for (const w of words) {
-    const next = slug.length === 0 ? w : `${slug}-${w}`;
-    if (next.length > TARGET_SLUG_LENGTH && slug.length > 0) break;
-    if (next.length > MAX_SLUG_LENGTH) break;
-    slug = next;
-  }
-  if (slug.length === 0) {
-    slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SLUG_LENGTH).replace(/-+$/, "");
-  }
-  return SAFE_SLUG.test(slug) ? slug : chunkR3UPQFKK_cjs.safeFilenameForId(text);
-}
-function titleForFact(text) {
-  const words = topicWords(text);
-  if (words.length === 0) return text.trim().slice(0, TITLE_MAX_LENGTH);
-  let title = "";
-  let used = 0;
-  for (const w of words) {
-    if (used >= TITLE_MAX_WORDS) break;
-    const next = title.length === 0 ? w : `${title} ${w}`;
-    if (next.length > TITLE_MAX_LENGTH && title.length > 0) break;
-    title = next;
-    used += 1;
-  }
-  if (title.length === 0) title = words[0];
-  return title.charAt(0).toUpperCase() + title.slice(1);
-}
-function readMetadata(raw) {
-  const metadata = raw ?? {};
-  const rawKind = metadata.type;
-  const kind = typeof rawKind === "string" && MEMORY_KINDS.includes(rawKind) ? rawKind : void 0;
-  const modified = typeof metadata.modified === "string" ? metadata.modified : void 0;
-  const observations = readObservationCount(metadata.observations);
-  return {
-    ...kind !== void 0 ? { kind } : {},
-    ...modified !== void 0 ? { modified } : {},
-    ...observations !== void 0 ? { observations } : {}
-  };
-}
-function readObservationCount(raw) {
-  if (typeof raw !== "number") return void 0;
-  if (!Number.isInteger(raw) || raw <= 0) return void 0;
-  return raw;
-}
-function renderMemoryFile(fields) {
-  const metadata = ["  node_type: memory"];
-  if (fields.kind !== void 0) metadata.push(`  type: ${fields.kind}`);
-  if (fields.modified !== void 0) metadata.push(`  modified: ${fields.modified}`);
-  if (fields.observations !== void 0) {
-    metadata.push(`  observations: ${fields.observations}`);
-  }
-  return [
-    "---",
-    `name: ${fields.name}`,
-    `description: ${JSON.stringify(fields.description)}`,
-    "metadata:",
-    ...metadata,
-    "---",
-    "",
-    fields.body,
-    ""
-  ].join("\n");
-}
-function parseMemoryFile(raw) {
-  const { yaml, body } = chunkKRD3GQAA_cjs.splitFrontmatter(raw);
-  if (yaml === void 0) return void 0;
-  let fields;
-  try {
-    fields = chunkKRD3GQAA_cjs.parseSimpleYaml(yaml);
-  } catch {
-    return void 0;
-  }
-  const name = fields.name;
-  const description = fields.description;
-  if (typeof name !== "string" || typeof description !== "string") return void 0;
-  return {
-    name,
-    description,
-    ...readMetadata(fields.metadata),
-    body: body.trim()
-  };
-}
-
-// src/internal/memory/storage/threat-scan.ts
-var INVISIBLE_CLASS = "\\u200B-\\u200F\\u202A-\\u202E\\u2066-\\u2069\\uFEFF";
-var THREAT_PATTERNS = [
-  {
-    id: "invisible_unicode",
-    // Text that renders as one thing to a reviewer and another to a parser is the whole
-    // technique.
-    test: new RegExp(`[${INVISIBLE_CLASS}]`, "u"),
-    why: "contains invisible or bidirectional control characters"
-  },
-  {
-    id: "instruction_override",
-    // The framing that tries to make recalled text outrank the system prompt. A memory entry
-    // states what was learned; it never addresses the model's instructions.
-    test: /\b(?:ignore|disregard|forget|override)\s+(?:all\s+|any\s+|the\s+|your\s+|previous\s+|prior\s+|earlier\s+|above\s+)*(?:instruction|prompt|rule|directive|guideline|system\s+prompt)/i,
-    why: "addresses the model's instructions instead of stating what was learned"
-  },
-  {
-    id: "role_reassignment",
-    test: /\b(?:you\s+are\s+now|from\s+now\s+on\s+you\s+(?:are|will|must)|new\s+system\s+prompt|act\s+as\s+(?:if\s+you\s+are\s+)?(?:an?\s+)?(?:unrestricted|jailbroken|developer\s+mode))/i,
-    why: "attempts to reassign the agent's role"
-  },
-  // A `pipe_to_shell` pattern (`curl … | sh`) was written here and REMOVED after measurement.
-  // It fired on 1 of 797 real memory files, and the hit was legitimate: a note documenting the
-  // product's own install command in a table. Fetch-and-execute in a hostile entry and in an
-  // install instruction are textually identical, so the pattern cannot be narrowed — only
-  // traded. Rejecting the write would mean the first person to save install docs to memory
-  // gets a hard failure, which buys nothing: an entry the agent READS is not an entry the
-  // agent RUNS, and execution is gated at the tool boundary, where it belongs. Left out on
-  // purpose, so nobody re-adds it without repeating the measurement.
-  {
-    id: "encoded_payload",
-    // A base64 run this long is not prose. Short tokens are left alone precisely so that hashes,
-    // commit SHAs and identifiers keep working.
-    test: /[A-Za-z0-9+/]{256,}={0,2}/,
-    why: "carries a long encoded payload rather than readable text"
-  }
-];
-var EXCERPT_RADIUS = 40;
-var EXCERPT_SCRUB = new RegExp(`[\\u0000-\\u001F${INVISIBLE_CLASS}]`, "gu");
-function scanForThreats(text) {
-  for (const pattern of THREAT_PATTERNS) {
-    const m = pattern.test.exec(text);
-    if (m === null) continue;
-    const at = m.index;
-    const start = Math.max(0, at - EXCERPT_RADIUS);
-    const end = Math.min(text.length, at + m[0].length + EXCERPT_RADIUS);
-    const window = text.slice(start, end).replace(EXCERPT_SCRUB, "\u2423");
-    return {
-      id: pattern.id,
-      why: pattern.why,
-      excerpt: `${start > 0 ? "\u2026" : ""}${window}${end < text.length ? "\u2026" : ""}`
-    };
-  }
-  return void 0;
-}
-THREAT_PATTERNS.map((p) => p.id);
-
-// src/internal/memory/storage/markdown-store.ts
-var MEMORY_MD_HEADER = "# Memory Index\n";
-var FACTS_HEADING = "## Facts";
-var MAX_NAME_VARIANTS = 50;
-function memoryDir(cwd) {
-  return path.join(cwd, ".theokit", "memory");
-}
-function memoryWriteDir(cwd, sessionDir) {
-  if (sessionDir === void 0 || sessionDir.trim().length === 0) return memoryDir(cwd);
-  return path.join(sessionDir, "projects", chunkBUIK7GUA_cjs.encodeProjectDir(cwd), "memory");
-}
-function claudeProjectMemoryDir(cwd) {
-  const home = process.env.CLAUDE_CONFIG_DIR?.trim();
-  const root = home !== void 0 && home.length > 0 ? home : path.join(os.homedir(), ".claude");
-  return path.join(root, "projects", chunkBUIK7GUA_cjs.encodeProjectDir(cwd), "memory");
-}
-function memoryMdPath(cwd) {
-  return path.join(memoryDir(cwd), "MEMORY.md");
-}
-function notesDir(cwd) {
-  return path.join(memoryDir(cwd), "notes");
-}
-function byNaturalName(a, b) {
-  const split = (f) => {
-    const stem = f.replace(/\.md$/, "");
-    const m = /^(.*?)-(\d+)$/.exec(stem);
-    return m === null ? [stem, 0] : [m[1], Number(m[2])];
-  };
-  const [baseA, nA] = split(a);
-  const [baseB, nB] = split(b);
-  return baseA === baseB ? nA - nB : baseA.localeCompare(baseB);
-}
-async function readFactsFromMarkdown(cwd, sessionDir) {
-  const facts = [];
-  const roots = [
-    .../* @__PURE__ */ new Set([memoryDir(cwd), memoryWriteDir(cwd, sessionDir), claudeProjectMemoryDir(cwd)])
-  ];
-  for (const dir of roots) {
-    let entries;
-    try {
-      entries = await promises.readdir(dir);
-    } catch {
-      continue;
-    }
-    const inDir = [];
-    for (const entry of entries.sort(byNaturalName)) {
-      const fact = await readMemoryFileIn(dir, entry);
-      if (fact !== void 0) inDir.push(fact);
-    }
-    inDir.sort((a, b) => (a.modified ?? "").localeCompare(b.modified ?? ""));
-    facts.push(...inDir);
-  }
-  try {
-    facts.push(...parseFactsSection(await promises.readFile(memoryMdPath(cwd), "utf8")));
-  } catch {
-  }
-  return facts;
-}
-async function readMemoryFileIn(dir, entry) {
-  if (!entry.endsWith(".md") || entry === "MEMORY.md") return void 0;
-  let raw;
-  try {
-    raw = await promises.readFile(path.join(dir, entry), "utf8");
-  } catch {
-    return void 0;
-  }
-  const parsed = parseMemoryFile(raw);
-  if (parsed === void 0) return void 0;
-  const body = parsed.body.trim();
-  return {
-    text: body.length > 0 ? body : parsed.description,
-    ...parsed.kind !== void 0 ? { kind: parsed.kind } : {},
-    ...parsed.modified !== void 0 ? { modified: parsed.modified } : {},
-    ...parsed.observations !== void 0 ? { observations: parsed.observations } : {}
-  };
-}
-function assertWritable(fact, text) {
-  if (fact.kind !== void 0 && !MEMORY_KINDS.includes(fact.kind)) {
-    throw new chunkK3FW2XZD_cjs.ConfigurationError(
-      `Unknown memory fact kind "${fact.kind}". Expected one of: ${MEMORY_KINDS.join(", ")}.`,
-      { code: "invalid_memory_kind" }
-    );
-  }
-  const threat = scanForThreats(text);
-  if (threat !== void 0) {
-    throw new chunkK3FW2XZD_cjs.ConfigurationError(
-      `Refusing to write a memory entry that ${threat.why}: ${threat.excerpt}`,
-      { code: "memory_threat_rejected" }
-    );
-  }
-}
-function appendFactToMarkdown(cwd, fact, targetDir = memoryDir(cwd)) {
-  return chunkZF2LDKQQ_cjs.withCwdMutex(targetDir, async () => {
-    const text = chunkJTB5Q42C_cjs.redactSecrets(fact.text);
-    assertWritable(fact, text);
-    const title = fact.title?.trim() ?? titleForFact(text);
-    const base = fact.title !== void 0 ? slugForFact(fact.title) : slugForFact(text);
-    await promises.mkdir(targetDir, { recursive: true });
-    const name = await resolveName(targetDir, base, text);
-    const description = fact.description?.trim() ?? text;
-    const observations = await nextObservationCount(targetDir, name, text);
-    await chunkI6TGFUCO_cjs.replaceFileAtomic(
-      path.join(targetDir, `${name}.md`),
-      renderMemoryFile({
-        name,
-        description,
-        ...fact.kind !== void 0 ? { kind: fact.kind } : {},
-        modified: (/* @__PURE__ */ new Date()).toISOString(),
-        observations,
-        body: text
-      })
-    );
-    await chunkI6TGFUCO_cjs.replaceFileAtomic(
-      path.join(targetDir, "MEMORY.md"),
-      await nextIndex(targetDir, description, name, title)
-    );
-  });
-}
-async function resolveName(dir, base, text) {
-  const wanted = normalizeFactText(text);
-  for (let i = 1; i <= MAX_NAME_VARIANTS; i += 1) {
-    const candidate = i === 1 ? base : `${base}-${i}`;
-    let existing;
-    try {
-      existing = await promises.readFile(path.join(dir, `${candidate}.md`), "utf8");
-    } catch {
-      return candidate;
-    }
-    const parsed = parseMemoryFile(existing);
-    if (parsed === void 0) return candidate;
-    if (normalizeFactText(parsed.body) === wanted) return candidate;
-  }
-  return slugForFact(text) === base ? chunkR3UPQFKK_cjs.safeFilenameForId(text) : slugForFact(text);
-}
-async function nextObservationCount(dir, name, text) {
-  let existing;
-  try {
-    existing = await promises.readFile(path.join(dir, `${name}.md`), "utf8");
-  } catch {
-    return 1;
-  }
-  const parsed = parseMemoryFile(existing);
-  if (parsed === void 0) return 1;
-  const sameFact = normalizeFactText(parsed.body) === normalizeFactText(text);
-  if (!sameFact) return 1;
-  return (parsed.observations ?? 1) + 1;
-}
-function normalizeFactText(text) {
-  return text.trim().toLowerCase().replace(/\s+/g, " ").replace(/[.!?]+$/, "");
-}
-async function nextIndex(dir, text, name, title) {
-  let existing = "";
-  try {
-    existing = await promises.readFile(path.join(dir, "MEMORY.md"), "utf8");
-  } catch {
-    existing = "";
-  }
-  const hook = text.replace(/\s+/g, " ").trim();
-  const entry = hook.length > 0 && hook !== title ? `- [${title}](${name}.md) \u2014 ${hook}` : `- [${title}](${name}.md)`;
-  const kept = existing.split("\n").filter((line) => !line.startsWith(`- [`) || !line.includes(`](${name}.md)`));
-  const body = kept.join("\n").trimEnd();
-  const head = body.length > 0 ? body : MEMORY_MD_HEADER;
-  return `${head}
-${entry}
-`;
-}
-var INDEX_ENTRY = /^\[[^\]]*\]\([^)]+\.md\)(?:\s+—\s.*)?$/;
-function parseFactsSection(raw) {
-  const idx = raw.indexOf(FACTS_HEADING);
-  if (idx === -1) return [];
-  const tail = raw.slice(idx + FACTS_HEADING.length);
-  const nextHeading = tail.search(/\n#{1,2}\s/);
-  const block = nextHeading === -1 ? tail : tail.slice(0, nextHeading);
-  return block.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => line.slice(2).trim()).filter((body) => !INDEX_ENTRY.test(body)).map((body) => ({ text: body }));
-}
-async function readFacts(cwd, config, memoryHome) {
-  if (!config.enabled) return [];
-  return readFactsFromMarkdown(cwd, memoryHome);
-}
-async function appendFact(cwd, config, fact, memoryHome) {
-  if (!config.enabled) return;
-  await appendFactToMarkdown(cwd, fact, memoryWriteDir(cwd, memoryHome));
-}
-
-exports.MEMORY_KINDS = MEMORY_KINDS;
-exports.appendFact = appendFact;
-exports.appendFactToMarkdown = appendFactToMarkdown;
-exports.claudeProjectMemoryDir = claudeProjectMemoryDir;
-exports.legacyMemoryJsonPath = legacyMemoryJsonPath;
-exports.memoryDir = memoryDir;
-exports.memoryMdPath = memoryMdPath;
-exports.memoryWriteDir = memoryWriteDir;
-exports.notesDir = notesDir;
-exports.readFacts = readFacts;
-exports.readFactsFromMarkdown = readFactsFromMarkdown;
-//# sourceMappingURL=chunk-2UCFUSPW.cjs.map
-//# sourceMappingURL=chunk-2UCFUSPW.cjs.map