@letrquan/book 0.2.0 → 0.3.0

package/dist/chunk-6OQQOMZR.js

@@ -0,0 +1,785 @@
+import {
+  permissionRuleMatchesCall
+} from "./chunk-J62VZYOB.js";
+import {
+  parseFrontmatter
+} from "./chunk-KXAYUIKP.js";
+import {
+  writeFileAtomic
+} from "./chunk-X4NJT436.js";
+import {
+  resolveBookHome
+} from "./chunk-ZPSZZUWF.js";
+
+// src/memory-store.ts
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { createHash } from "crypto";
+import { basename, isAbsolute, join, relative, resolve } from "path";
+
+// src/secret-detect.ts
+var SECRET_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/i,
+  /\b(api[_-]?key|token|password|passwd|secret)\s*[:=]\s*\S{8,}/i,
+  /https?:\/\/[^\s/]+:[^\s/]+@/i,
+  /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/
+];
+function containsSecretPattern(text) {
+  return SECRET_PATTERNS.some((re) => re.test(text));
+}
+function looksLikeSecretOrUnfit(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return "empty";
+  if (SECRET_PATTERNS.some((re) => re.test(trimmed))) return "looks like a secret";
+  const longTokens = trimmed.match(/[A-Za-z0-9+/=_-]{48,}/g) ?? [];
+  if (longTokens.some((token) => new Set(token).size > 20)) return "contains high-entropy text";
+  return null;
+}
+
+// src/memory-store.ts
+var MEMORY_TYPES = ["user", "feedback", "project", "reference"];
+var MAX_BODY_CHARS = 1600;
+function sanitizeMemorySlug(rawSlug) {
+  const cleaned = rawSlug.replace(/[\x00-\x1f\x7f]/g, "").replace(/[/\\]/g, "").replace(/[[\]()]/g, "").trim().replace(/^\.+/, "").trim();
+  return cleaned.length > 0 ? cleaned : null;
+}
+function lastSlugSegment(raw) {
+  return raw.split(/[/\\]/).pop() ?? "";
+}
+function memoryFileForSlug(dir, raw) {
+  const cleanSlug = sanitizeMemorySlug(lastSlugSegment(raw.trim()));
+  if (!cleanSlug) return { error: "Invalid memory slug." };
+  const filename = cleanSlug.toLowerCase().endsWith(".md") ? cleanSlug : `${cleanSlug}.md`;
+  if (filename.toLowerCase() === INDEX_FILE.toLowerCase()) {
+    return { error: "Target filename cannot be the index file." };
+  }
+  const target = join(dir, filename);
+  const rel = relative(dir, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    return { error: "Target path must stay inside the project memory directory." };
+  }
+  return { filename, target };
+}
+function rulesNameMemorySave(rules) {
+  return rules.some(
+    (rule) => permissionRuleMatchesCall(rule, { id: "memory", name: "MemorySave", arguments: {} })
+  );
+}
+function isMemorySaveAvailable(settings) {
+  if (!settings?.memory) return true;
+  return settings.memory.enabled !== false && settings.memory.autoSave !== false;
+}
+function memoryWriteScope(config) {
+  if (!isMemorySaveAvailable(config.settings)) return "none";
+  return config.sessionDriver === "agent" ? "learnings" : "full";
+}
+function canModelWriteMemory(config) {
+  return memoryWriteScope(config) !== "none";
+}
+var DELEGATED_MEMORY_TYPES = ["project", "reference"];
+function sanitizeMemoryTitle(rawTitle) {
+  return rawTitle.replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/[[\]()]/g, "").replace(/^[\s#]+/, "").replace(/\s+/g, " ").trim().slice(0, 120).trim();
+}
+function shouldRejectMemoryText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return "empty";
+  if (trimmed.length > MAX_BODY_CHARS * 2) return "too long";
+  return looksLikeSecretOrUnfit(trimmed);
+}
+var DEFAULT_MAX_INDEX_LINES = 200;
+var INDEX_FILE = "MEMORY.md";
+var INBOX_DIR = ".inbox";
+var DISCARDED_DIR = "discarded";
+function slugifyWorkspace(workspace) {
+  return workspace.replace(/[/\\:]+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function bookRoot(opts) {
+  return opts?.bookRoot ?? resolveBookHome();
+}
+function getProjectMemoryDir(workspace, opts) {
+  return join(bookRoot(opts), "projects", slugifyWorkspace(workspace), "memory");
+}
+function getMemoryInboxDir(workspace, opts) {
+  return opts?.dir ? join(opts.dir, INBOX_DIR) : join(getProjectMemoryDir(workspace, opts), INBOX_DIR);
+}
+function getMemoryExtractionStatePath(workspace, opts) {
+  return join(getProjectMemoryDir(workspace, opts), ".extraction-state.json");
+}
+function getMemoryExtractionLockPath(workspace, opts) {
+  return join(getProjectMemoryDir(workspace, opts), ".extraction.lock");
+}
+function isMemoryType(value) {
+  return typeof value === "string" && MEMORY_TYPES.includes(value);
+}
+function isMemoryStatus(value) {
+  return value === "approved" || value === "pending" || value === "discarded" || value === "superseded";
+}
+function titleFromBody(body) {
+  const firstHeading = body.split("\n").find((line) => line.startsWith("# "));
+  return firstHeading?.replace(/^#\s+/, "").trim();
+}
+function summarizeMemoryFile(path, name = basename(path)) {
+  try {
+    const st = statSync(path);
+    if (!st.isFile()) return null;
+    const raw = readFileSync(path, "utf-8");
+    const { body, frontmatter } = parseFrontmatter(raw);
+    const proposedTitle = typeof frontmatter.proposedTitle === "string" ? frontmatter.proposedTitle : void 0;
+    const title = proposedTitle ?? (typeof frontmatter.title === "string" ? frontmatter.title : void 0) ?? titleFromBody(body);
+    return {
+      name,
+      path,
+      type: isMemoryType(frontmatter.type) ? frontmatter.type : void 0,
+      status: isMemoryStatus(frontmatter.status) ? frontmatter.status : void 0,
+      title,
+      created: typeof frontmatter.created === "string" ? frontmatter.created : void 0,
+      updated: typeof frontmatter.updated === "string" ? frontmatter.updated : void 0,
+      size: st.size,
+      ...frontmatter.driver === "agent" ? { driver: "agent" } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function listMemoryFiles(workspace, opts) {
+  const dir = getProjectMemoryDir(workspace, opts);
+  if (!existsSync(dir)) return [];
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir).sort()) {
+      if (!entry.toLowerCase().endsWith(".md")) continue;
+      if (entry.toLowerCase() === INDEX_FILE.toLowerCase()) continue;
+      const full = join(dir, entry);
+      const summary = summarizeMemoryFile(full, entry);
+      if (summary && summary.status !== "superseded") files.push(summary);
+    }
+  } catch {
+    return files;
+  }
+  return files;
+}
+function listMemoryCandidates(workspace, opts) {
+  const dir = getMemoryInboxDir(workspace, opts);
+  if (!existsSync(dir)) return [];
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir).sort()) {
+      if (!entry.endsWith(".md")) continue;
+      const full = join(dir, entry);
+      const summary = summarizeMemoryFile(full, entry);
+      if (summary) files.push(summary);
+    }
+  } catch {
+    return files;
+  }
+  return files;
+}
+function countMemoryCandidates(workspace, opts) {
+  const dir = getMemoryInboxDir(workspace, opts);
+  if (!existsSync(dir)) return 0;
+  try {
+    return readdirSync(dir).filter((entry) => !entry.startsWith(".") && entry.endsWith(".md")).length;
+  } catch {
+    return 0;
+  }
+}
+function readFirstLines(path, maxLines) {
+  const raw = readFileSync(path, "utf-8");
+  const lines = raw.split("\n");
+  const loaded = lines.slice(0, maxLines);
+  return {
+    text: loaded.join("\n").trim(),
+    totalLines: lines.filter((line) => line.trim().length > 0).length,
+    loadedLines: loaded.filter((line) => line.trim().length > 0).length
+  };
+}
+function loadMemoryContext(workspace, opts) {
+  const dir = getProjectMemoryDir(workspace, opts);
+  const maxIndexLines = opts?.maxIndexLines ?? DEFAULT_MAX_INDEX_LINES;
+  const result = {
+    dir,
+    indexFile: null,
+    indexLoaded: false,
+    indexLineCount: 0,
+    loadedLineCount: 0,
+    indexText: "",
+    files: [],
+    candidates: []
+  };
+  if (!existsSync(dir)) return result;
+  const indexFile = join(dir, INDEX_FILE);
+  if (existsSync(indexFile)) {
+    try {
+      const st = statSync(indexFile);
+      if (st.isFile()) {
+        const index = readFirstLines(indexFile, maxIndexLines);
+        result.indexFile = indexFile;
+        result.indexLoaded = index.text.length > 0;
+        result.indexLineCount = index.totalLines;
+        result.loadedLineCount = index.loadedLines;
+        result.indexText = index.text;
+      }
+    } catch {
+      result.indexFile = indexFile;
+    }
+  }
+  result.files = listMemoryFiles(workspace, opts);
+  result.candidates = listMemoryCandidates(workspace, opts);
+  return result;
+}
+function getNewestMemoryWriteTime(memoryDir) {
+  if (!existsSync(memoryDir)) return null;
+  let newestMs = 0;
+  function scanEntries(dir, isInbox) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".")) {
+        if (!isInbox && entry === INBOX_DIR) {
+          scanEntries(join(dir, entry), true);
+        }
+        continue;
+      }
+      if (isInbox && entry === DISCARDED_DIR) {
+        continue;
+      }
+      const full = join(dir, entry);
+      try {
+        const st = lstatSync(full);
+        if (st.isSymbolicLink()) continue;
+        if (st.isFile()) {
+          if (st.mtimeMs > newestMs) newestMs = st.mtimeMs;
+        }
+      } catch {
+      }
+    }
+  }
+  scanEntries(memoryDir, false);
+  return newestMs > 0 ? new Date(newestMs) : null;
+}
+function getMemoryHealth(workspaceOrContext, opts) {
+  const dir = typeof workspaceOrContext === "string" ? opts?.dir ?? getProjectMemoryDir(workspaceOrContext, opts) : workspaceOrContext.dir;
+  const workspace = typeof workspaceOrContext === "string" ? workspaceOrContext : "";
+  let approvedCount = 0;
+  let supersededCount = 0;
+  if (existsSync(dir)) {
+    try {
+      for (const entry of readdirSync(dir)) {
+        if (!entry.toLowerCase().endsWith(".md") || entry.toLowerCase() === INDEX_FILE.toLowerCase())
+          continue;
+        const full = join(dir, entry);
+        try {
+          const st = lstatSync(full);
+          if (st.isSymbolicLink() || !st.isFile()) continue;
+          const summary = summarizeMemoryFile(full, entry);
+          if (summary && (summary.status === "approved" || summary.status === void 0)) {
+            approvedCount++;
+          } else if (summary?.status === "superseded") {
+            supersededCount++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const inboxCount = countMemoryCandidates(workspace, { ...opts, dir });
+  let indexLineCount = 0;
+  try {
+    indexLineCount = readIndexLines(dir).length;
+  } catch {
+  }
+  const lastWrite = getNewestMemoryWriteTime(dir);
+  return {
+    approvedCount,
+    supersededCount,
+    inboxCount,
+    indexLineCount,
+    lastWrite
+  };
+}
+function safeTitle(title) {
+  return title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "memory";
+}
+function shortHash(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function formatTags(tags) {
+  if (!tags?.length) return "";
+  return `tags:
+${tags.map((tag) => `- ${tag}`).join("\n")}
+`;
+}
+function renderMemoryMarkdown(input, status, now) {
+  const created = input.created ?? now.toISOString();
+  const updated = now.toISOString();
+  const sanitizedTitle = sanitizeMemoryTitle(input.title);
+  const title = status === "pending" ? `Candidate: ${sanitizedTitle}` : sanitizedTitle;
+  const origin = input.origin ?? "user-text";
+  const source = input.source ?? (origin === "user-text" ? "manual" : "auto");
+  const externalContext = input.externalContext ?? false;
+  const fm = [
+    `type: ${input.type}`,
+    `status: ${status}`,
+    `origin: ${origin}`,
+    `source: ${source}`,
+    `externalContext: ${externalContext}`,
+    `created: ${created}`,
+    `updated: ${updated}`
+  ];
+  if (input.sessionId) fm.push(`sessionId: ${input.sessionId}`);
+  if (input.driver === "agent") fm.push("driver: agent");
+  if (input.evidence?.length) {
+    fm.push(`evidence:
+${input.evidence.map((e) => `- ${e}`).join("\n")}`);
+  }
+  if (input.targetSlug) fm.push(`targetSlug: ${input.targetSlug}`);
+  if (input.supersedes) fm.push(`supersedes: ${input.supersedes}`);
+  if (input.supersededBy) fm.push(`supersededBy: ${input.supersededBy}`);
+  if ("confidence" in input && input.confidence) fm.push(`confidence: ${input.confidence}`);
+  if (status === "pending") fm.push(`proposedTitle: ${sanitizedTitle}`);
+  if (input.tags?.length) {
+    fm.push(formatTags(input.tags).trimEnd());
+  }
+  return ["---", ...fm, "---", "", `# ${title}`, "", input.body.trim(), ""].join("\n");
+}
+function writeMemoryCandidate(workspace, candidate, opts) {
+  try {
+    const title = sanitizeMemoryTitle(candidate.title);
+    if (!title) {
+      return { ok: false, error: "title must not be empty after sanitizing." };
+    }
+    const now = opts?.now ?? /* @__PURE__ */ new Date();
+    const inbox = getMemoryInboxDir(workspace, opts);
+    mkdirSync(inbox, { recursive: true });
+    const stamp = now.toISOString().replace(/[-:.]/g, "").slice(0, 15);
+    const hash = shortHash(`${candidate.type}
+${title}
+${candidate.body}
+${now.toISOString()}`);
+    const filename = `${stamp}-cand-${safeTitle(title)}-${hash}.md`;
+    const path = join(inbox, filename);
+    writeFileSync(path, renderMemoryMarkdown({ ...candidate, title }, "pending", now), "utf-8");
+    return { ok: true, path };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function resolveCandidatePath(workspace, candidateFile, opts) {
+  const inbox = resolve(getMemoryInboxDir(workspace, opts));
+  const raw = isAbsolute(candidateFile) ? candidateFile : join(inbox, candidateFile);
+  const resolved = resolve(raw);
+  const rel = relative(inbox, resolved);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  return resolved;
+}
+function activeMemoryFilename(input, now) {
+  const date = now.toISOString().slice(0, 10);
+  const hash = shortHash(`${input.type}
+${input.title}
+${input.body}`);
+  return `${date}-${input.type}-${safeTitle(input.title)}-${hash}.md`;
+}
+function frontmatterSlug(raw) {
+  return raw?.trim() ? sanitizeMemorySlug(lastSlugSegment(raw.trim())) ?? void 0 : void 0;
+}
+function readMemoryFile(path) {
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const { body, frontmatter } = parseFrontmatter(raw);
+    if (!isMemoryType(frontmatter.type)) return null;
+    const rawProposed = typeof frontmatter.proposedTitle === "string" ? frontmatter.proposedTitle : void 0;
+    const proposedTitle = rawProposed ? sanitizeMemoryTitle(rawProposed) || void 0 : void 0;
+    const heading = titleFromBody(body)?.replace(/^Candidate:\s*/i, "");
+    const title = proposedTitle || (typeof frontmatter.title === "string" ? sanitizeMemoryTitle(frontmatter.title) : "") || (heading ? sanitizeMemoryTitle(heading) : "") || basename(path, ".md");
+    const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags.filter((t) => typeof t === "string") : void 0;
+    const evidence = Array.isArray(frontmatter.evidence) ? frontmatter.evidence.filter((e) => typeof e === "string") : void 0;
+    const cleanBody = body.replace(/^#\s+[^\n]*\n+/i, "").trim() || body.trim();
+    const origin = frontmatter.origin === "model-tool" || frontmatter.origin === "extraction" || frontmatter.origin === "user-text" ? frontmatter.origin : "user-text";
+    const source = frontmatter.source === "manual" || frontmatter.source === "auto" ? frontmatter.source : origin === "user-text" ? "manual" : "auto";
+    const externalContext = frontmatter.externalContext === true || frontmatter.externalContext === "true";
+    const sessionId = typeof frontmatter.sessionId === "string" ? frontmatter.sessionId : void 0;
+    const rawTargetSlug = typeof frontmatter.targetSlug === "string" ? frontmatter.targetSlug : void 0;
+    const targetSlug = frontmatterSlug(rawTargetSlug);
+    const status = isMemoryStatus(frontmatter.status) ? frontmatter.status : void 0;
+    const created = typeof frontmatter.created === "string" ? frontmatter.created : void 0;
+    const updated = typeof frontmatter.updated === "string" ? frontmatter.updated : void 0;
+    const supersedes = frontmatterSlug(
+      typeof frontmatter.supersedes === "string" ? frontmatter.supersedes : void 0
+    );
+    return {
+      supersedes,
+      type: frontmatter.type,
+      title,
+      body: cleanBody,
+      origin,
+      source,
+      externalContext,
+      sessionId,
+      evidence,
+      targetSlug,
+      status,
+      confidence: frontmatter.confidence === "low" || frontmatter.confidence === "medium" || frontmatter.confidence === "high" ? frontmatter.confidence : void 0,
+      tags,
+      created,
+      updated,
+      ...frontmatter.driver === "agent" ? { driver: "agent" } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function parseCandidateFile(path) {
+  return readMemoryFile(path);
+}
+var INDEX_UNSAFE = /[\x00-\x1f\x7f-\x9f[\]()<>]/g;
+function indexHook(body) {
+  const first = body.trim().split("\n")[0]?.replace(INDEX_UNSAFE, " ").replace(/\s+/g, " ").trim() ?? "";
+  return first.length > 100 ? `${first.slice(0, 100)}\u2026` : first;
+}
+var sameFile = (a, b) => a.toLowerCase() === b.toLowerCase();
+function indexEntryFile(line) {
+  return /^- \[[^\]]*\]\(([^()]+)\)/.exec(line)?.[1];
+}
+function readIndexLines(dir) {
+  const indexPath = join(dir, INDEX_FILE);
+  if (!existsSync(indexPath)) return [];
+  return readFileSync(indexPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+}
+function writeIndexLines(dir, lines) {
+  writeFileAtomic(
+    join(dir, INDEX_FILE),
+    lines.length > 0 ? lines.join("\n") + "\n" : "# Book memory index\n"
+  );
+}
+function liveIndexLines(dir, lines, drop) {
+  return lines.filter((line) => {
+    const file = indexEntryFile(line);
+    if (!file) return true;
+    if (drop.some((name) => sameFile(name, file))) return false;
+    const path = join(dir, file);
+    if (!existsSync(path)) return false;
+    return summarizeMemoryFile(path, file)?.status !== "superseded";
+  });
+}
+function removeIndexEntry(dir, filename) {
+  if (!existsSync(join(dir, INDEX_FILE))) return;
+  writeIndexLines(dir, liveIndexLines(dir, readIndexLines(dir), [filename]));
+}
+function updateMemoryIndex(dir, title, filename, type, now, body, supersedes) {
+  const hook = indexHook(body);
+  const entry = `- [${title}](${filename}) \u2014 ${type} \u2014 ${now.toISOString().slice(0, 10)}${hook && hook !== title ? ` \u2014 ${hook}` : ""}`;
+  const drop = supersedes ? [filename, supersedes] : [filename];
+  let lines = liveIndexLines(dir, readIndexLines(dir), drop);
+  if (lines.length === 0) {
+    lines = ["# Book memory index", entry];
+  } else if (lines[0].startsWith("#")) {
+    lines = [lines[0], entry, ...lines.slice(1)];
+  } else {
+    lines = [entry, ...lines];
+  }
+  writeIndexLines(dir, lines);
+  return { entry, lineCount: lines.length };
+}
+function setFrontmatterFields(raw, fields) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
+  const entries = Object.entries(fields);
+  if (!match) {
+    return `---
+${entries.map(([k, v]) => `${k}: ${v}`).join("\n")}
+---
+
+${raw}`;
+  }
+  let frontmatter = match[1];
+  for (const [key, value] of entries) {
+    const line = new RegExp(`^${key}:.*$`, "m");
+    frontmatter = line.test(frontmatter) ? frontmatter.replace(line, `${key}: ${value}`) : `${frontmatter}
+${key}: ${value}`;
+  }
+  return `---
+${frontmatter}
+---
+${raw.slice(match[0].length)}`;
+}
+function markSuperseded(dir, oldFilename, byFilename, now) {
+  try {
+    const target = join(dir, oldFilename);
+    if (isSymlink(target)) return;
+    const raw = readFileSync(target, "utf-8");
+    writeFileAtomic(
+      target,
+      setFrontmatterFields(raw, {
+        status: "superseded",
+        supersededBy: byFilename,
+        updated: now.toISOString()
+      })
+    );
+  } catch {
+  }
+}
+function resolveSupersedes(dir, raw, own) {
+  if (!raw?.trim()) return {};
+  const named = memoryFileForSlug(dir, raw);
+  if ("error" in named) return { error: `supersedes: ${named.error}` };
+  let actual;
+  try {
+    actual = readdirSync(dir).find((f) => sameFile(f, named.filename));
+  } catch {
+    actual = void 0;
+  }
+  if (!actual || isSymlink(join(dir, actual))) {
+    return {
+      error: `supersedes: no memory file ${named.filename}. Use the file name from <memory-index>.`
+    };
+  }
+  if (own && sameFile(actual, own)) return {};
+  const current = summarizeMemoryFile(join(dir, actual), actual);
+  if (current?.status === "superseded") {
+    return {
+      error: `supersedes: ${actual} is already superseded; supersede its replacement instead.`
+    };
+  }
+  return { filename: actual };
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function approvedTarget(dir, input, slug, now) {
+  const named = slug?.trim() ? memoryFileForSlug(dir, slug) : null;
+  if (named && "error" in named) return { error: named.error };
+  const filename = named?.filename ?? activeMemoryFilename(input, now);
+  const target = named?.target ?? join(dir, filename);
+  if (isSymlink(target)) return { error: "Refusing to overwrite symlinked memory file." };
+  const existingCreated = named && existsSync(target) ? readMemoryFile(target)?.created : void 0;
+  return { filename, target, existingCreated };
+}
+function saveMemory(workspace, candidate, opts) {
+  const quarantineExternal = opts?.quarantineExternal ?? true;
+  const isQuarantined = candidate.externalContext === true && quarantineExternal;
+  const requireApproval = (opts?.requireApproval ?? false) || isQuarantined;
+  const title = sanitizeMemoryTitle(candidate.title);
+  if (!title) {
+    return {
+      ok: false,
+      error: "title must not be empty after sanitizing.",
+      status: requireApproval ? "pending" : "approved",
+      quarantined: isQuarantined
+    };
+  }
+  if (requireApproval) {
+    const rawSlug = opts?.slug?.trim() ? opts.slug : candidate.targetSlug?.trim() ? candidate.targetSlug : void 0;
+    let targetSlug;
+    if (rawSlug) {
+      const named = memoryFileForSlug(getProjectMemoryDir(workspace, opts), rawSlug);
+      if ("error" in named) {
+        return { ok: false, error: named.error, status: "pending", quarantined: isQuarantined };
+      }
+      targetSlug = named.filename;
+    }
+    const retire = resolveSupersedes(
+      getProjectMemoryDir(workspace, opts),
+      candidate.supersedes,
+      targetSlug
+    );
+    if ("error" in retire) {
+      return { ok: false, error: retire.error, status: "pending", quarantined: isQuarantined };
+    }
+    const candidateInput = {
+      ...candidate,
+      title,
+      targetSlug,
+      supersedes: retire.filename
+    };
+    const writeResult = writeMemoryCandidate(workspace, candidateInput, opts);
+    if (!writeResult.ok) {
+      return { ok: false, error: writeResult.error, status: "pending", quarantined: isQuarantined };
+    }
+    return { ok: true, path: writeResult.path, status: "pending", quarantined: isQuarantined };
+  }
+  try {
+    const now = opts?.now ?? /* @__PURE__ */ new Date();
+    const dir = getProjectMemoryDir(workspace, opts);
+    mkdirSync(dir, { recursive: true });
+    const placed = approvedTarget(dir, { ...candidate, title }, opts?.slug, now);
+    if ("error" in placed) return { ok: false, error: placed.error, status: "approved" };
+    const { filename, target, existingCreated } = placed;
+    const retire = resolveSupersedes(dir, candidate.supersedes, filename);
+    if ("error" in retire) return { ok: false, error: retire.error, status: "approved" };
+    readIndexLines(dir);
+    const memoryInput = {
+      ...candidate,
+      title,
+      supersedes: retire.filename,
+      created: existingCreated ?? candidate.created
+    };
+    writeFileSync(target, renderMemoryMarkdown(memoryInput, "approved", now), "utf-8");
+    const index = updateMemoryIndex(
+      dir,
+      title,
+      filename,
+      candidate.type,
+      now,
+      candidate.body,
+      memoryInput.supersedes
+    );
+    if (memoryInput.supersedes) markSuperseded(dir, memoryInput.supersedes, filename, now);
+    return {
+      ok: true,
+      path: target,
+      indexLine: index.entry,
+      indexLineCount: index.lineCount,
+      retired: memoryInput.supersedes,
+      status: "approved"
+    };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e), status: "approved" };
+  }
+}
+function memoryEntryDriver(workspace, slug, opts) {
+  const named = memoryFileForSlug(getProjectMemoryDir(workspace, opts), slug);
+  if ("error" in named || !existsSync(named.target)) return null;
+  return readMemoryFile(named.target)?.driver === "agent" ? "agent" : "human";
+}
+function deleteMemoryEntry(workspace, slug, opts) {
+  try {
+    const dir = getProjectMemoryDir(workspace, opts);
+    const named = memoryFileForSlug(dir, slug);
+    if ("error" in named) return { ok: false, error: named.error };
+    const { filename, target } = named;
+    if (!existsSync(target)) {
+      return { ok: false, error: `Memory file not found: ${filename}` };
+    }
+    if (lstatSync(target).isSymbolicLink()) {
+      return { ok: false, error: "Refusing to delete symlinked file." };
+    }
+    unlinkSync(target);
+    try {
+      removeIndexEntry(dir, filename);
+    } catch {
+    }
+    return { ok: true, path: target };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function approveMemoryCandidate(workspace, candidateFile, opts) {
+  try {
+    const candidatePath = resolveCandidatePath(workspace, candidateFile, opts);
+    if (!candidatePath)
+      return { ok: false, error: "Candidate path must stay inside the memory inbox." };
+    if (!existsSync(candidatePath))
+      return { ok: false, error: `Candidate not found: ${candidateFile}` };
+    if (lstatSync(candidatePath).isSymbolicLink())
+      return { ok: false, error: "Refusing to approve symlinked candidate." };
+    const candidate = parseCandidateFile(candidatePath);
+    if (!candidate)
+      return { ok: false, error: "Candidate has invalid or missing memory frontmatter." };
+    const now = opts?.now ?? /* @__PURE__ */ new Date();
+    const dir = getProjectMemoryDir(workspace, opts);
+    mkdirSync(dir, { recursive: true });
+    if (!candidate.title.trim()) return { ok: false, error: "Candidate has an empty title." };
+    const placed = approvedTarget(dir, candidate, candidate.targetSlug, now);
+    if ("error" in placed) return { ok: false, error: placed.error };
+    const { filename, target, existingCreated } = placed;
+    const retire = resolveSupersedes(dir, candidate.supersedes, filename);
+    const supersedes = "error" in retire ? void 0 : retire.filename;
+    const retireSkipped = "error" in retire ? retire.error : void 0;
+    const memoryInput = {
+      ...candidate,
+      supersedes,
+      created: existingCreated ?? candidate.created
+    };
+    const rendered = renderMemoryMarkdown(memoryInput, "approved", now);
+    readIndexLines(dir);
+    renameSync(candidatePath, join(getDiscardedDir(workspace, opts), basename(candidatePath)));
+    writeFileSync(target, rendered, "utf-8");
+    updateMemoryIndex(
+      dir,
+      candidate.title,
+      filename,
+      candidate.type,
+      now,
+      candidate.body,
+      supersedes
+    );
+    if (supersedes) markSuperseded(dir, supersedes, filename, now);
+    return { ok: true, path: target, retired: supersedes, retireSkipped };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function getDiscardedDir(workspace, opts) {
+  const dir = join(getMemoryInboxDir(workspace, opts), DISCARDED_DIR);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function discardMemoryCandidate(workspace, candidateFile, opts) {
+  try {
+    const candidatePath = resolveCandidatePath(workspace, candidateFile, opts);
+    if (!candidatePath)
+      return { ok: false, error: "Candidate path must stay inside the memory inbox." };
+    if (!existsSync(candidatePath))
+      return { ok: false, error: `Candidate not found: ${candidateFile}` };
+    if (lstatSync(candidatePath).isSymbolicLink())
+      return { ok: false, error: "Refusing to discard symlinked candidate." };
+    const discardedPath = join(getDiscardedDir(workspace, opts), basename(candidatePath));
+    renameSync(candidatePath, discardedPath);
+    return { ok: true, path: discardedPath };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+export {
+  containsSecretPattern,
+  MEMORY_TYPES,
+  MAX_BODY_CHARS,
+  sanitizeMemorySlug,
+  memoryFileForSlug,
+  rulesNameMemorySave,
+  isMemorySaveAvailable,
+  memoryWriteScope,
+  canModelWriteMemory,
+  DELEGATED_MEMORY_TYPES,
+  sanitizeMemoryTitle,
+  shouldRejectMemoryText,
+  DEFAULT_MAX_INDEX_LINES,
+  slugifyWorkspace,
+  getProjectMemoryDir,
+  getMemoryInboxDir,
+  getMemoryExtractionStatePath,
+  getMemoryExtractionLockPath,
+  listMemoryFiles,
+  listMemoryCandidates,
+  countMemoryCandidates,
+  loadMemoryContext,
+  getNewestMemoryWriteTime,
+  getMemoryHealth,
+  writeMemoryCandidate,
+  readMemoryFile,
+  saveMemory,
+  memoryEntryDriver,
+  deleteMemoryEntry,
+  approveMemoryCandidate,
+  discardMemoryCandidate
+};
+//# sourceMappingURL=chunk-6OQQOMZR.js.map