open-memex 0.1.0 → 0.3.0-alpha

package/scripts/smoke-mcp.ts

@@ -0,0 +1,135 @@
+// MCP server smoke test: handshake + tools/list + add/search/forget over stdio.
+// Usage:  node --experimental-strip-types scripts/smoke-mcp.ts
+// Uses temp dirs for MY_O_MEMORY_HOME and the project cwd — no real data touched.
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOME = fs.mkdtempSync(path.join(os.tmpdir(), "mcp-home-"));
+const PROJ = fs.mkdtempSync(path.join(os.tmpdir(), "mcp-proj-"));
+
+const MCP_TS = fileURLToPath(new URL("../src/mcp.ts", import.meta.url));
+
+const child = spawn(
+  "node",
+  ["--experimental-strip-types", MCP_TS],
+  {
+    cwd: PROJ,
+    env: { ...process.env, MY_O_MEMORY_HOME: HOME },
+    stdio: ["pipe", "pipe", "pipe"],
+  },
+);
+
+let buf = "";
+let id = 0;
+const pending = new Map<number, (v: any) => void>();
+const stdoutLines: string[] = [];
+
+child.stdout.on("data", (d) => {
+  buf += d.toString();
+  let idx;
+  while ((idx = buf.indexOf("\n")) >= 0) {
+    const line = buf.slice(0, idx).trim();
+    buf = buf.slice(idx + 1);
+    if (!line) continue;
+    stdoutLines.push(line);
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      console.error("NON-JSON on stdout:", line);
+      process.exitCode = 1;
+      continue;
+    }
+    if (msg.id !== undefined && pending.has(msg.id)) {
+      pending.get(msg.id)!(msg);
+      pending.delete(msg.id);
+    }
+  }
+});
+child.stderr.on("data", (d) => process.stderr.write("[srv:err] " + d.toString()));
+
+function req(method: string, params?: any): Promise<any> {
+  const myId = ++id;
+  return new Promise((resolve) => {
+    pending.set(myId, resolve);
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: myId, method, params }) + "\n");
+  });
+}
+function notify(method: string, params?: any) {
+  child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+}
+
+const results: string[] = [];
+function check(name: string, ok: boolean, detail = "") {
+  results.push(`${ok ? "PASS" : "FAIL"} ${name}${detail ? " — " + detail : ""}`);
+  if (!ok) process.exitCode = 1;
+}
+
+try {
+  const init = await req("initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "mcp-e2e", version: "0.0.1" },
+  });
+  check("initialize", !!init.result?.serverInfo, JSON.stringify(init.result?.serverInfo));
+  notify("notifications/initialized");
+
+  const tools = await req("tools/list", {});
+  const names = (tools.result?.tools ?? []).map((t: any) => t.name).sort();
+  check(
+    "tools/list has 5 memory tools",
+    JSON.stringify(names) ===
+      JSON.stringify(["memory_add", "memory_forget", "memory_list", "memory_search", "memory_supersede"]),
+    names.join(","),
+  );
+  const addSchema = tools.result.tools.find((t: any) => t.name === "memory_add").inputSchema;
+  check("memory_add schema has content+type+scope+tags", !!addSchema.properties?.content && !!addSchema.properties?.type, Object.keys(addSchema.properties ?? {}).join(","));
+
+  // D14 through MCP: a fake secret must be masked, not refused.
+  const add = await req("tools/call", {
+    name: "memory_add",
+    arguments: { content: "mcp e2e probe: deploy key sk-test-FAKESECRET1234567890abcdef", type: "fact" },
+  });
+  const addText: string = add.result?.content?.[0]?.text ?? "";
+  const savedId = (addText.match(/id=([A-Za-z0-9_]+)/) ?? [])[1];
+  check("memory_add saves (not refuses)", !add.result?.isError && !!savedId, addText.slice(0, 80));
+  check("memory_add notes masking (D14)", addText.includes("masked"), addText.slice(0, 120));
+
+  // The raw secret must not be on disk.
+  const mdFiles: string[] = [];
+  const walk = (d: string) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith(".md")) mdFiles.push(p);
+    }
+  };
+  walk(HOME);
+  const leaked = mdFiles.filter((f) => fs.readFileSync(f, "utf8").includes("sk-test-FAKESECRET1234567890abcdef"));
+  check("secret not leaked to disk", leaked.length === 0, leaked.join(","));
+
+  const search = await req("tools/call", {
+    name: "memory_search",
+    arguments: { query: "mcp e2e probe" },
+  });
+  const searchText: string = search.result?.content?.[0]?.text ?? "";
+  check("memory_search finds it", searchText.includes(savedId), searchText.slice(0, 80));
+  check("memory_search output masked", !searchText.includes("sk-test-FAKESECRET1234567890abcdef"));
+
+  const list = await req("tools/call", { name: "memory_list", arguments: {} });
+  check("memory_list works", (list.result?.content?.[0]?.text ?? "").includes(savedId));
+
+  const forget = await req("tools/call", { name: "memory_forget", arguments: { id: savedId } });
+  check("memory_forget works", (forget.result?.content?.[0]?.text ?? "").includes("Deleted"));
+
+  const search2 = await req("tools/call", { name: "memory_search", arguments: { query: "mcp e2e probe" } });
+  check("memory gone after forget", !(search2.result?.content?.[0]?.text ?? "").includes(savedId));
+} finally {
+  child.kill();
+}
+
+console.log(results.join("\n"));
+console.log(process.exitCode ? "MCP E2E: FAILURES" : "MCP E2E: ALL PASS");

package/scripts/smoke-pure.ts

@@ -1,10 +1,13 @@
 // Quick smoke test — runs the pure-logic modules (no bun:sqlite dependency).
 // Usage:  node --experimental-strip-types scripts\smoke-pure.ts
-import { parse, serialize, ulid, type Frontmatter } from "../src/store/markdown.ts";
+import { parse, serialize, ulid, normalizeFrontmatter, msToRfc3339, timeToMs, parseRawFrontmatter, type Frontmatter } from "../src/store/markdown.ts";
+import { planConversion, isV2File } from "../src/store/v2migrate.ts";
 import { redact, findSecret } from "../src/redact.ts";
 import { detectKeywords } from "../src/capture/keywords.ts";
 import { DEFAULT_CONFIG } from "../src/config.ts";
-import { resolveProjectScope, resolveCwdScope, USER_SCOPE } from "../src/scope.ts";
+import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/scope.ts";
+import { cjkIndexText, cjkQueryExpr, hasCjk } from "../src/retrieve/cjk.ts";
+import { contentHash, similarity, NEAR_DUP_THRESHOLD } from "../src/store/lifecycle.ts";
 
 let fails = 0;
 function ok(name: string, cond: boolean, info?: unknown) {
@@ -20,19 +23,28 @@ const a = ulid();
 const b = ulid();
 ok("length is 26", a.length === 26);
 ok("two calls differ", a !== b);
-ok("sortable", a < b || a === b);
+// NOTE: same-ms monotonicity is NOT guaranteed — the 16-char suffix is
+// random by design (timestamp prefix still gives rough ordering).
+ok("time prefix is 10 chars", a.slice(0, 10).length === 10);
 
-console.log("== markdown round-trip ==");
+console.log("== markdown round-trip (v2) ==");
 const fm: Frontmatter = {
   id: a,
+  schema_version: 2,
   scope_key: "project__test__abcdef123456",
-  scope_kind: "project",
+  scope: "project",
+  visibility: "internal",
   project_name: "test",
-  type: "note",
+  type: "fact",
+  role: "knowledge",
+  importance: "normal",
+  status: "active",
   tags: ["hello", "world"],
   source: "test",
-  created_at: 1000,
-  updated_at: 2000,
+  created_at: msToRfc3339(1000),
+  updated_at: msToRfc3339(2000),
+  supersedes: null,
+  superseded_by: null,
 };
 const body = "hello\n\nworld";
 const raw = serialize(fm, body);
@@ -54,6 +66,123 @@ ok("bare secret detected", r2.hadSecret === true);
 const r3 = redact("ghp_" + "a".repeat(36), DEFAULT_CONFIG.redactPatterns);
 ok("github PAT detected", r3.hadSecret === true);
 
+console.log("== redact hardening ==");
+import {
+  BUILTIN_SECRET_PATTERNS,
+  findBuiltinSecret,
+  findHighEntropySecret,
+  stripPrivate,
+} from "../src/redact.ts";
+
+// Every builtin pattern fires on a realistic sample, reported by id.
+const builtinSamples: Array<[string, string]> = [
+  ["openai-key", "key=sk-1234567890abcdefghij1234"],
+  ["github-oauth-token", "tok=gho_12345678901234567890123456789012"],
+  ["github-fine-grained-pat", "tok=github_pat_1234567890123456789012345678901234567890"],
+  ["aws-access-key-id", "id=AKIA1234567890ABCDEF"],
+  ["slack-token", "tok=xoxb-123456789012-abcdefghij"],
+  ["google-api-key", "k=AIza12345678901234567890123456789012"],
+  ["npm-token", "t=npm_12345678901234567890123456789012"],
+  ["gitlab-pat", "t=glpat-12345678901234567890ab"],
+  ["stripe-webhook-secret", "s=whsec_12345678901234567890"],
+  ["private-key-block", "-----BEGIN RSA PRIVATE KEY-----\nQUJD\n-----END RSA PRIVATE KEY-----"],
+  ["private-key-truncated", "-----BEGIN RSA PRIVATE KEY-----"],
+  ["generic-secret-assignment", 'password = "hunter2hunter2hunter2"'],
+];
+for (const [id, sample] of builtinSamples) {
+  const r = redact(`note: ${sample} end`, []);
+  ok(`builtin ${id} detected`, r.hadSecret === true && r.matchedPattern === id, r.matchedPattern);
+}
+// All builtin regexes compile.
+ok(
+  "all builtins compile",
+  BUILTIN_SECRET_PATTERNS.every((p) => {
+    try {
+      new RegExp(p.source, p.flags ?? "");
+      return true;
+    } catch {
+      return false;
+    }
+  }),
+);
+// Non-secrets pass.
+const benign = [
+  "remember that the meeting is at 3pm tomorrow",
+  "the api endpoint is https://api.example.com/v1/users/list",
+  "commit = a3f5c81234abcd1234abcd1234abcd1234abcd12",
+  "version = 1.2.3-alpha.4",
+  "note = aaaaaaaaaaaaaaaaaaaaaaaa",
+  "token: abc",
+  // sk- inside ordinary words must not trip the openai-key pattern
+  // (regression: these were refused as "openai-key" before the boundary guard).
+  "the task-management-system-workflow-2024 document is here",
+  "disk-encryption-key-management-system-v2 rollout notes",
+  "risk-assessment-score-2024-10 update",
+];
+for (const b of benign) {
+  const r = redact(b, []);
+  ok(`benign passes: ${b.slice(0, 40)}`, r.hadSecret === false, r.matchedPattern);
+}
+// High-entropy heuristic.
+const entropic = findHighEntropySecret('deploy_key = "aB3dE5fG7hJ9kL2mN4pQ6rS8tU0vW2xY4zA6bC8dE0"');
+ok("high-entropy assignment caught", entropic === "high-entropy-secret:deploy_key", entropic);
+ok("low-entropy passes", findHighEntropySecret('note = "aaaaaaaaaaaaaaaaaaaaaaaa"') === null);
+ok("hex digest passes", findHighEntropySecret("commit = a3f5c81234abcd1234abcd1234abcd1234abcd12") === null);
+// <private> handling.
+ok(
+  "unclosed private redacts to end",
+  stripPrivate("hello <private>my secret") === "hello [REDACTED]",
+);
+ok(
+  "closed private still stripped",
+  stripPrivate("a <private>x</private> b") === "a [REDACTED] b",
+);
+const r4 = redact("token is <private>sk-1234567890abcdefghij1234</private> ok", []);
+ok("wrapped secret does not trigger", r4.hadSecret === false);
+// User patterns still work, reported verbatim.
+const r5 = redact("foo CUSTOM123 bar", ["CUSTOM\\d+"]);
+ok("user pattern detected", r5.hadSecret === true && r5.matchedPattern === "CUSTOM\\d+", r5.matchedPattern);
+
+console.log("== redact masking (D14) ==");
+// Secrets are masked in place (first 4 chars kept, rest → x), never refused.
+const m1 = redact("deploy uses key=sk-1234567890abcdefghij1234 in prod", []);
+ok("mask: detected", m1.hadSecret === true && m1.matchedPattern === "openai-key", m1.matchedPattern);
+ok("mask: prefix kept", m1.content.includes("sk-1"), m1.content);
+ok("mask: rest x'd", m1.content.includes("sk-1xxxxxxxxxxxxxxxxxxxxx"), m1.content);
+ok("mask: full secret gone", !m1.content.includes("1234567890abcdefghij"));
+ok("mask: surrounding text kept", m1.content.startsWith("deploy uses key=") && m1.content.includes(" in prod"));
+// User patterns mask too.
+ok("mask: user pattern", redact("foo CUSTOM123 bar", ["CUSTOM\\d+"]).content.includes("CUSTxxxxx"));
+// High-entropy: value masked, name kept.
+const r6 = redact('deploy_key = "aB3dE5fG7hJ9kL2mN4pQ6rS8tU0vW2xY4zA6bC8dE0"', []);
+ok("mask: entropy value masked", r6.content.includes("aB3dxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"), r6.content);
+ok("mask: entropy name kept", r6.content.includes("deploy_key ="));
+// URLs are never masked, even when another secret is present in the same text.
+const r7 = redact("see https://api.example.com/v1/users/list and key=sk-1234567890abcdefghij1234", []);
+ok("mask: mixed url+secret detected", r7.hadSecret === true, r7.matchedPattern);
+ok("mask: url intact", r7.content.includes("https://api.example.com/v1/users/list"), r7.content);
+ok("mask: second secret also masked", !r7.content.includes("sk-1234567890"), r7.content);
+// Bare high-entropy URL: the scheme colon must not turn the URL into a secret.
+const r8 = redact("see https://aB3dEfGhIjKlMnOpQrStUvWx0123456789abcdef for details", []);
+ok("mask: bare url untouched", r8.hadSecret === false && r8.content.includes("https://aB3dEfGhIjKlMnOpQrStUvWx0123456789abcdef"), r8.content);
+// Private key: the WHOLE block is masked, body must not survive in readable form.
+const pemBody = "MIIEpAIBAAKCAQEA7bXprGBcW2l5K3R8vN0mQw0F3xY2vBn5T6uI7oP8a9S0dF1gH";
+const r9 = redact(`note: server key\n-----BEGIN RSA PRIVATE KEY-----\n${pemBody}\n-----END RSA PRIVATE KEY-----\nafter`, []);
+ok("mask: pem detected", r9.hadSecret === true && r9.matchedPattern === "private-key-block", r9.matchedPattern);
+ok("mask: pem body gone", !r9.content.includes(pemBody), r9.content);
+ok("mask: pem surrounding kept", r9.content.includes("note: server key") && r9.content.includes("after"));
+// Truncated key (no END marker): masked to end of text.
+const r10 = redact(`note\n-----BEGIN RSA PRIVATE KEY-----\n${pemBody}\ntrailing prose`, []);
+ok("mask: truncated pem detected", r10.hadSecret === true, r10.matchedPattern);
+ok("mask: truncated pem body gone", !r10.content.includes(pemBody) && !r10.content.includes("trailing prose"), r10.content);
+// Name-including patterns mask the value only; the name stays readable (D14).
+const r11 = redact('api_key = "supersecretvalue123456"', []);
+ok("mask: generic name kept", r11.content.includes("api_key ="), r11.content);
+ok("mask: generic value masked", !r11.content.includes("supersecretvalue123456") && r11.content.includes("supexxxxxxxxxxxxxxxx"), r11.content);
+const r12 = redact('aws_secret_access_key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCY1234567890"', []);
+ok("mask: aws name kept", r12.content.includes("aws_secret_access_key ="), r12.content);
+ok("mask: aws value masked", !r12.content.includes("wJalrXUtnFEMI"), r12.content);
+
 console.log("== keywords ==");
 const hits1 = detectKeywords("remember that this repo uses Bun, not Node", DEFAULT_CONFIG);
 ok("basic remember matched", hits1.length === 1);
@@ -74,7 +203,9 @@ ok("kind=project", s.kind === "project");
 ok("key starts with project__", s.key.startsWith("project__"));
 ok("hash length 12", /__[a-f0-9]{12}$/.test(s.key));
 console.log("     scope.key =", s.key);
-console.log("     user.key  =", USER_SCOPE.key);
+console.log("     personal.key =", PERSONAL_SCOPE.key);
+ok("personal scope key", PERSONAL_SCOPE.key === "personal");
+ok("personal scope kind", PERSONAL_SCOPE.kind === "personal");
 
 console.log("== scope (cwd-only legacy) ==");
 const cwdOnly = resolveCwdScope(process.cwd());
@@ -87,5 +218,115 @@ ok("cwd scope deterministic", cwdOnly.key === cwdOnly2.key);
 // (This repo does have an origin after `git push`.)
 console.log("     cwd.key   =", cwdOnly.key);
 
+console.log("== cjk ==");
+ok("detects han", hasCjk("中文记忆"));
+ok("detects mixed", hasCjk("open中文"));
+ok("no cjk in latin", !hasCjk("hello world 123"));
+ok(
+  "index bigrams",
+  cjkIndexText("中文记忆") === "中 文 记 忆 中文 文记 记忆",
+  cjkIndexText("中文记忆"),
+);
+ok("index single char", cjkIndexText("猫") === "猫", cjkIndexText("猫"));
+ok(
+  "index skips latin",
+  cjkIndexText("open中文") === "中 文 中文",
+  cjkIndexText("open中文"),
+);
+ok("index empty", cjkIndexText("hello") === "");
+ok(
+  "query bigrams",
+  cjkQueryExpr("中文记忆") === '"中文" OR "文记" OR "记忆"',
+  cjkQueryExpr("中文记忆"),
+);
+ok("query single char", cjkQueryExpr("猫") === '"猫"', cjkQueryExpr("猫"));
+ok("query no cjk", cjkQueryExpr("hello") === "");
+
+console.log("== v2 times ==");
+ok("epoch 0 → rfc3339", msToRfc3339(0) === "1970-01-01T00:00:00Z", msToRfc3339(0));
+ok("rfc3339 round-trip", timeToMs(msToRfc3339(1758854400000)) === 1758854400000);
+ok("timeToMs accepts epoch", timeToMs(1000) === 1000);
+ok("timeToMs accepts rfc3339", timeToMs("2026-09-26T12:00:00Z") === Date.parse("2026-09-26T12:00:00Z"));
+
+console.log("== v1 → v2 normalize ==");
+const v1raw = {
+  id: "01TESTV1",
+  scope_key: "user",
+  scope_kind: "user",
+  project_name: "user",
+  type: "instruction",
+  priority: 9,
+  tags: ["x"],
+  source: "test",
+  created_at: 1758854400000,
+  updated_at: 1758854400000,
+} as Record<string, unknown>;
+const nfm = normalizeFrontmatter(v1raw);
+ok("scope user→personal", nfm.scope === "personal", nfm.scope);
+ok("scope_key user→personal", nfm.scope_key === "personal", nfm.scope_key);
+ok("visibility private", nfm.visibility === "private", nfm.visibility);
+ok("type instruction→knowledge", nfm.type === "knowledge", nfm.type);
+ok("role →instruction", nfm.role === "instruction", nfm.role);
+ok("priority 9→high", nfm.importance === "high", nfm.importance);
+ok("epoch→rfc3339", nfm.created_at === "2025-09-26T02:40:00Z", nfm.created_at);
+ok("status active", nfm.status === "active");
+ok("schema_version 2", nfm.schema_version === 2);
+
+const v1raw2 = {
+  id: "01TESTV2",
+  scope_key: "project__x__abcdef123456",
+  scope_kind: "project",
+  project_name: "x",
+  type: "error-solution",
+  priority: 2,
+  tags: [],
+  created_at: 1000,
+  updated_at: 1000,
+} as Record<string, unknown>;
+const nfm2 = normalizeFrontmatter(v1raw2);
+ok("project scope kept", nfm2.scope === "project");
+ok("project visibility internal", nfm2.visibility === "internal");
+ok("priority 2→low", nfm2.importance === "low");
+ok("role default knowledge", nfm2.role === "knowledge");
+
+console.log("== v1 → v2 planConversion ==");
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "v2mig-"));
+const memRoot = path.join(tmpRoot, "memories");
+fs.mkdirSync(path.join(memRoot, "user"), { recursive: true });
+const v1file = `---\nid: 01PLANTEST\nscope_key: user\nscope_kind: user\nproject_name: user\ntype: note\npriority: 5\ntags: []\nsource: test\ncreated_at: 1758854400000\nupdated_at: 1758854400000\n---\n\n记得买菜\n`;
+const v1path = path.join(memRoot, "user", "01PLANTEST.md");
+fs.writeFileSync(v1path, v1file, "utf8");
+ok("v1 not v2 file", !isV2File(v1file));
+const plan = planConversion(v1path, memRoot);
+ok("plan exists", plan !== null);
+ok("plan moves to personal/", plan?.toPath === path.join(memRoot, "personal", "01PLANTEST.md"), plan?.toPath);
+ok("plan notes unknown type", plan?.changes.some((c) => c.includes('"note" → knowledge')) ?? false, plan?.changes);
+ok("plan notes scope rename", plan?.changes.some((c) => c.includes("personal")) ?? false);
+ok("plan fm scope personal", plan?.fm.scope === "personal");
+const v2raw = serialize(plan!.fm, plan!.body);
+ok("v2 marker detected", isV2File(v2raw));
+ok("already-v2 → null plan", planConversion(v1path, memRoot) !== null); // file still v1 on disk
+fs.writeFileSync(v1path, v2raw, "utf8");
+const plan2 = planConversion(v1path, memRoot);
+ok("v2 on disk → null plan", plan2 === null);
+fs.rmSync(tmpRoot, { recursive: true, force: true });
+
+console.log("== lifecycle pure: contentHash / similarity ==");
+ok("hash deterministic + whitespace-insensitive", contentHash("hello   world\n") === contentHash("hello world"));
+ok("hash differs on content", contentHash("hello world") !== contentHash("hello mars"));
+ok("hash is sha256 hex", /^[0-9a-f]{64}$/.test(contentHash("x")));
+ok("similarity identical latin = 1", similarity("apple banana", "apple banana") === 1);
+ok("similarity identical CJK = 1", similarity("北京烤鸭好吃", "北京烤鸭好吃") === 1);
+ok("similarity disjoint ≈ 0", similarity("apple banana", "car train") < 0.2);
+const near = similarity(
+  "the meeting notes from tuesday about deployment",
+  "meeting notes from tuesday about deployment",
+);
+ok(`similarity near-dup ${near.toFixed(2)} >= ${NEAR_DUP_THRESHOLD}`, near >= NEAR_DUP_THRESHOLD);
+ok("similarity empty → 0", similarity("", "anything") === 0);
+
 console.log(fails === 0 ? "\nALL PASS" : `\n${fails} FAILURES`);
 process.exit(fails === 0 ? 0 : 1);

package/src/capture/keywords.ts

@@ -3,32 +3,45 @@ import type { MyOMemoryConfig } from "../config.ts";
 export interface KeywordHit {
   content: string;
   pattern: string;
+  /** True when the hit came from a personal-scope pattern: force personal scope. */
+  personal: boolean;
 }
 
 /**
  * Scan user text for memory-capture keyword triggers.
  * Each pattern must have a single capture group whose value becomes the memory body.
+ * Personal patterns (cfg.keywordPersonalPatterns) force the personal scope.
+ *
+ * Personal patterns run first and claim their line: an explicit scope signal
+ * (e.g. "记住我对花粉过敏") must not also fire the generic 记住 into the project scope.
  */
 export function detectKeywords(userText: string, cfg: MyOMemoryConfig): KeywordHit[] {
   if (!cfg.keywordCaptureEnabled) return [];
   const hits: KeywordHit[] = [];
   const lines = userText.split(/\r?\n/);
-  for (const src of cfg.keywordPatterns) {
-    let re: RegExp;
-    try {
-      re = new RegExp(src, "i");
-    } catch {
-      continue;
-    }
-    for (const line of lines) {
-      const m = line.match(re);
-      if (!m || !m[1]) continue;
-      const content = m[1].trim().replace(/[.!?]$/, "").trim();
-      if (content.length >= 3 && content.length <= 2000) {
-        hits.push({ content, pattern: src });
-        break; // one hit per pattern per message
+  const claimed = new Set<number>();
+  const scan = (patterns: string[], personal: boolean, skipClaimed: boolean) => {
+    for (const src of patterns) {
+      let re: RegExp;
+      try {
+        re = new RegExp(src, "i");
+      } catch {
+        continue;
+      }
+      for (let i = 0; i < lines.length; i++) {
+        if (skipClaimed && claimed.has(i)) continue;
+        const m = lines[i].match(re);
+        if (!m || !m[1]) continue;
+        const content = m[1].trim().replace(/[.!?]$/, "").trim();
+        if (content.length >= 3 && content.length <= 2000) {
+          hits.push({ content, pattern: src, personal });
+          if (personal) claimed.add(i);
+          break; // one hit per pattern per message
+        }
       }
     }
-  }
+  };
+  scan(cfg.keywordPersonalPatterns, true, false);
+  scan(cfg.keywordPatterns, false, true);
   return hits;
 }