open-memex 0.7.3 → 0.8.0-alpha.3

package/src/retrieve/query.ts

@@ -14,7 +14,7 @@
 import { cjkQueryExpr, hasCjk } from "./cjk.ts";
 
 /** English function words that carry no retrieval signal in questions. */
-const LATIN_STOPWORDS = new Set([
+export const LATIN_STOPWORDS = new Set([
   "the", "a", "an", "and", "or", "of", "to", "in", "on", "for", "with",
   "without", "is", "are", "was", "were", "be", "been", "do", "does", "did",
   "how", "what", "why", "when", "where", "which", "who", "whom", "we", "i",
@@ -32,9 +32,11 @@ const CJK_QUESTION_BIGRAMS = new Set([
 
 const MAX_TERMS = 24;
 
-function latinTerms(q: string): string[] {
+export function latinTerms(q: string, useStopwords = true): string[] {
   const raw = q.toLowerCase().match(/[a-z0-9_.\-]+/g) ?? [];
-  const kept = raw.filter((t) => t.length > 1 && !LATIN_STOPWORDS.has(t));
+  const kept = useStopwords
+    ? raw.filter((t) => t.length > 1 && !LATIN_STOPWORDS.has(t))
+    : raw.filter((t) => t.length > 1);
   const chosen = kept.length > 0 ? kept : raw;
   return [...new Set(chosen)].slice(0, MAX_TERMS);
 }
@@ -44,15 +46,27 @@ function latinTerms(q: string): string[] {
  * Latin tokens keep the old behavior (prefix match on content/tags/type).
  * CJK runs become an OR of bigrams against the `cjk` column (see cjk.ts).
  * Mixed queries OR the two parts together.
+ *
+ * Flags are ablation toggles (all default to the shipped behavior):
+ * - stopwords: false  → skip function-word filtering
+ * - orJoin: false     → AND the terms instead of OR
+ * - prefix: false     → exact term match instead of `term*`
  */
-export function toFtsQuery(q: string): string {
-  const latin = latinTerms(q)
-    .map((t) => `"${t.replace(/"/g, '""')}"*`)
-    .join(" OR ");
+export function toFtsQuery(
+  q: string,
+  flags: { stopwords?: boolean; orJoin?: boolean; prefix?: boolean } = {},
+): string {
+  const useStopwords = flags.stopwords !== false;
+  const useOr = flags.orJoin !== false;
+  const usePrefix = flags.prefix !== false;
+  const joiner = useOr ? " OR " : " AND ";
+  const latin = latinTerms(q, useStopwords)
+    .map((t) => (usePrefix ? `"${t.replace(/"/g, '""')}"*` : `"${t.replace(/"/g, '""')}"`))
+    .join(joiner);
   const cjk = hasCjk(q)
-    ? cjkQueryExpr(q, { dropBigrams: CJK_QUESTION_BIGRAMS, maxTerms: MAX_TERMS })
+    ? cjkQueryExpr(q, { dropBigrams: useStopwords ? CJK_QUESTION_BIGRAMS : undefined, maxTerms: MAX_TERMS })
     : "";
-  if (latin && cjk) return `(${latin}) OR {cjk}:(${cjk})`;
+  if (latin && cjk) return `(${latin}) ${useOr ? "OR" : "AND"} {cjk}:(${cjk})`;
   if (cjk) return `{cjk}:(${cjk})`;
   return latin;
 }

package/src/retrieve/search.ts

@@ -1,5 +1,10 @@
 import { db } from "../store/db.ts";
 import { toFtsQuery } from "./query.ts";
+import {
+  loadAliasEntries,
+  planAliasExpansions,
+  mergeRounds,
+} from "./alias-memory.ts";
 
 export interface SearchHit {
   id: string;
@@ -88,6 +93,8 @@ export interface SearchStats {
   candidates: number;
   hiddenSuperseded: number;
   hiddenExcluded: number;
+  /** D81: query-time alias expansions actually run (rounds 2+, raw text). */
+  aliasExpansions: string[];
 }
 
 /**
@@ -158,14 +165,25 @@ function resolveVisible(rows: RawRow[], limit: number, stats?: SearchStats): Sea
  */
 export function search(
   query: string,
-  opts: { scopeKeys?: string[]; limit?: number; type?: string; stats?: SearchStats } = {},
+  opts: {
+    scopeKeys?: string[];
+    limit?: number;
+    type?: string;
+    stats?: SearchStats;
+    /** Ablation toggles for query construction (default = shipped behavior). */
+    stopwords?: boolean;
+    orJoin?: boolean;
+    prefix?: boolean;
+  } = {},
 ): SearchHit[] {
-  const q = toFtsQuery(query);
+  const qflags = { stopwords: opts.stopwords, orJoin: opts.orJoin, prefix: opts.prefix };
+  const q = toFtsQuery(query, qflags);
   if (opts.stats) {
     opts.stats.ftsQuery = q;
     opts.stats.candidates = 0;
     opts.stats.hiddenSuperseded = 0;
     opts.stats.hiddenExcluded = 0;
+    opts.stats.aliasExpansions = [];
   }
   if (!q) return [];
   const limit = Math.max(1, Math.min(opts.limit ?? 8, 50));
@@ -190,14 +208,7 @@ export function search(
     ORDER BY score ASC
     LIMIT ?
   `;
-  const params: unknown[] = [q];
-  if (opts.scopeKeys && opts.scopeKeys.length > 0) params.push(...opts.scopeKeys);
-  if (opts.type) params.push(opts.type);
-  params.push(fetchLimit);
-
-  const rows = db()
-    .prepare(sql)
-    .all(...(params as any[])) as Array<{
+  type Row = {
     id: string;
     scope_key: string;
     project_name: string;
@@ -211,12 +222,53 @@ export function search(
     created_at: number;
     snippet: string;
     score: number;
-  }>;
+  };
+  const fetchFts = (matchExpr: string): RawRow[] => {
+    const params: unknown[] = [matchExpr];
+    if (opts.scopeKeys && opts.scopeKeys.length > 0) params.push(...opts.scopeKeys);
+    if (opts.type) params.push(opts.type);
+    params.push(fetchLimit);
+    const rows = db()
+      .prepare(sql)
+      .all(...(params as any[])) as Row[];
+    // FTS5 bm25: lower = better; invert for intuition.
+    return rows.map((r) => ({ ...r, score: -r.score }));
+  };
+
+  const raw: RawRow[] = fetchFts(q);
+
+  // D81: user-defined alias vocabulary — query-time expansion rounds.
+  // Round 1 is the query as-is; each further round rewrites alias terms to
+  // the other side of the relation (bidirectional, depth < 3). The trigger
+  // is an exact registry hit (loadAliasEntries), not a count heuristic.
+  const aliasEntries = loadAliasEntries(opts.scopeKeys);
+  const expansions = planAliasExpansions(query, aliasEntries);
+  let merged: RawRow[] = raw;
+  let finalLimit = limit;
+  if (expansions.length > 0) {
+    const rounds: RawRow[][] = [raw];
+    for (const eq of expansions) {
+      const mq = toFtsQuery(eq, qflags);
+      if (mq) rounds.push(fetchFts(mq));
+    }
+    // Normalized-max merge (alias-memory.ts): each round's scores are
+    // divided by that round's best, so an alias-side champion competes
+    // evenly with a literal-side champion — no down-weighting for being
+    // from a later round.
+    merged = mergeRounds(rounds).map((m) => ({ ...m.doc, score: m.score }));
+    // Cut to [1.5K, 2K] — never back to K, or round-2 hits would be
+    // starved the way D79's slice-to-K starved them.
+    const pool = merged.length;
+    finalLimit = Math.min(pool, 2 * limit);
+    finalLimit = Math.max(finalLimit, Math.min(pool, Math.ceil(1.5 * limit)));
+    if (opts.stats) opts.stats.aliasExpansions = expansions;
+  }
 
-  // FTS5 bm25: lower = better; invert for intuition.
-  const raw: RawRow[] = rows.map((r) => ({ ...r, score: -r.score }));
-  if (opts.stats) opts.stats.candidates = raw.length;
-  return resolveVisible(raw, limit, opts.stats);
+  // D80: the curated static map is solved at index time (synonyms.ts
+  // expands variants into the aliases column at sync time), so without a
+  // user alias the query side stays a single FTS round.
+  if (opts.stats) opts.stats.candidates = merged.length;
+  return resolveVisible(merged, finalLimit, opts.stats);
 }
 
 export function list(

package/src/retrieve/synonyms.ts

@@ -0,0 +1,184 @@
+/**
+ * Index-time synonym/translation expansion (D80).
+ *
+ * Stone's rule: solve vocabulary mismatch at write time, so any related
+ * word finds the answer with a plain round-1 query. At sync/index time
+ * every memory's keywords are expanded through a curated, checked-in
+ * equivalence map and the variants are written into the indexed `aliases`
+ * column (FTS + CJK bigram columns both pick them up via sync.ts). The
+ * query side stays simple: one FTS round, no trigger, no second chance.
+ *
+ * Deliberately NOT an embedding model or an LLM call: deterministic,
+ * auditable, zero dependencies, and the failure mode (a bad synonym)
+ * is a visible line in this file, not a silent vector.
+ *
+ * Groups are bidirectional — any member expands to the other members.
+ * Keep groups tight: an over-broad synonym costs precision on every
+ * query, and at index time a bad entry pollutes every document instead
+ * of one query. When in doubt, leave it out. A map update only reaches
+ * already-indexed memories after a reindex.
+ *
+ * Design note (D80): the map covers the *precise* slice — EN↔ZH
+ * translation pairs and dev-domain equivalents where embeddings are
+ * fuzzy (ship/deploy are neighbors in vector space but "单点登录"/SSO
+ * is an exact pair no embedding guarantees). Embeddings cover the
+ * semantic long tail; this map covers what must never be missed.
+ */
+
+import { LATIN_STOPWORDS } from "./query.ts";
+
+type Group = string[];
+
+const CJK_RE = /[\u4e00-\u9fff]/;
+
+/**
+ * Curated equivalence groups. EN dev-domain vocabulary, ZH equivalents,
+ * and EN↔ZH translation pairs live in one bidirectional group: any member
+ * expands to all the others, in either direction.
+ */
+const GROUPS: Group[] = [
+  ["deploy", "ship", "release", "rollout", "publish", "部署", "发布", "上线"],
+  ["test", "testing", "tests", "测试", "单测", "集成测试"],
+  ["regression test", "回归测试"],
+  ["rollback", "revert", "回滚", "撤回", "撤销", "回退"],
+  ["incident", "outage", "postmortem", "故障", "事故", "宕机"],
+  ["auth", "authentication", "login", "sso", "single sign-on", "单点登录", "登录"],
+  ["secret", "secrets", "credential", "credentials", "token", "密钥"],
+  ["database", "db", "数据库"],
+  ["backup", "restore", "备份", "恢复"],
+  ["retention", "保留"],
+  ["production", "生产", "生产环境"],
+  ["staging", "预发布环境", "预发布"],
+  ["wipe", "wipes", "清空", "清除"],
+  ["nightly", "night", "每晚"],
+  ["thursday", "周四", "星期四"],
+  ["mandatory", "强制", "必须"],
+  ["flaky", "flake", "unreliable", "intermittent"],
+  ["bug", "defect", "issue"],
+  ["ci", "pipeline"],
+  ["cache", "caching", "cached"],
+  ["invalidate", "invalidation", "expire", "expiry"],
+  ["oncall", "on-call", "pager"],
+  ["migration", "migrate", "migrating"],
+  ["index", "indexing", "indexed"],
+  ["slow", "latency", "performance", "perf"],
+  ["refactor", "refactoring"],
+  ["merge", "merging"],
+  ["branch", "branches"],
+  ["commit", "commits"],
+  ["review", "code review", "评审", "代码评审"],
+  ["mock", "stub"],
+  ["debug", "debugging", "troubleshoot", "troubleshooting"],
+  ["log", "logs", "logging"],
+  ["monitor", "monitoring", "alert", "alerting"],
+  ["scale", "scaling"],
+  ["timeout", "timeouts"],
+  ["retry", "retries"],
+  ["queue", "job", "worker"],
+  ["api", "endpoint"],
+  ["docker", "container", "image"],
+  ["kubernetes", "k8s"],
+  ["env", "environment"],
+  ["config", "configuration", "setting", "settings"],
+  ["hotfix", "hot fix"],
+  ["estimate", "estimation"],
+  ["乱码", "编码问题"],
+  ["并发", "并行"],
+  ["重构"],
+  ["规范", "约定"],
+];
+
+const termLookup = new Map<string, string[]>();
+const phraseEntries: Array<{ phrase: string; siblings: string[] }> = [];
+const cjkEntries: Array<{ keys: string[]; siblings: string[] }> = [];
+
+for (const g of GROUPS) {
+  const cjkKeys = g.filter((m) => CJK_RE.test(m));
+  if (cjkKeys.length > 0) cjkEntries.push({ keys: cjkKeys, siblings: [...g] });
+  for (const m of g) {
+    if (CJK_RE.test(m)) continue;
+    const siblings = g.filter((x) => x !== m);
+    if (m.includes(" ")) phraseEntries.push({ phrase: m.toLowerCase(), siblings });
+    else termLookup.set(m.toLowerCase(), siblings);
+  }
+}
+
+/**
+ * Synonym variants for one lowercased Latin term (excluding the term
+ * itself). Empty array when the term has no curated synonyms.
+ */
+export function synonymVariants(term: string): string[] {
+  return termLookup.get(term.toLowerCase()) ?? [];
+}
+
+/** Cap on auto-generated variants per memory — bounds index growth. */
+export const MAX_AUTO_VARIANTS = 32;
+
+/**
+ * Index-time expansion for one memory's text (body + tags). Keyword-
+ * centric (Stone): extract content terms, expand each through the
+ * curated map, return variants not already present in the text.
+ * Pure logic — safe to unit test, runs once per memory at sync time.
+ */
+export function expansionVariantsForDoc(text: string): string[] {
+  const lower = text.toLowerCase();
+  // Content terms only: function words carry no signal (same filter the
+  // query builder applies, so both sides agree on what a keyword is).
+  const latinTokens = new Set(
+    (lower.match(/[a-z0-9_.\-]+/g) ?? []).filter(
+      (t) => t.length > 1 && !LATIN_STOPWORDS.has(t),
+    ),
+  );
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const push = (v: string) => {
+    const key = v.toLowerCase();
+    if (seen.has(key) || out.length >= MAX_AUTO_VARIANTS) return;
+    seen.add(key);
+    out.push(v);
+  };
+  // A variant is "already present" when the doc has it as a token (Latin),
+  // as a substring (Latin phrase), or as a substring (CJK — no tokenizer).
+  const present = (v: string): boolean =>
+    CJK_RE.test(v)
+      ? text.includes(v)
+      : v.includes(" ")
+        ? lower.includes(v.toLowerCase())
+        : latinTokens.has(v.toLowerCase());
+
+  for (const t of latinTokens) {
+    for (const v of termLookup.get(t) ?? []) if (!present(v)) push(v);
+  }
+  for (const { phrase, siblings } of phraseEntries) {
+    if (!lower.includes(phrase)) continue;
+    for (const v of siblings) if (!present(v)) push(v);
+  }
+  for (const { keys, siblings } of cjkEntries) {
+    if (!keys.some((k) => text.includes(k))) continue;
+    for (const v of siblings) if (!present(v)) push(v);
+  }
+  return out;
+}
+
+/**
+ * Expand a raw query string with synonym variants (legacy query-time
+ * helper, kept for bench scripts). The product no longer expands at
+ * query time — D80 moved expansion to the index.
+ */
+export function expandQueryWithSynonyms(q: string): string {
+  const extra = new Set<string>();
+  const latinTerms = q.toLowerCase().match(/[a-z0-9_.\-]+/g) ?? [];
+  for (const t of latinTerms) {
+    for (const s of synonymVariants(t)) extra.add(s);
+  }
+  for (const { keys, siblings } of cjkEntries) {
+    if (keys.some((k) => q.includes(k))) {
+      for (const s of siblings) extra.add(s);
+    }
+  }
+  // Don't re-add terms already in the query.
+  const have = new Set(latinTerms);
+  const additions = [...extra].filter((s) => !have.has(s.toLowerCase()) && !q.includes(s));
+  if (additions.length === 0) return q;
+  return `${q} ${additions.join(" ")}`;
+}

package/src/store/db.ts

@@ -48,6 +48,8 @@ CREATE TABLE IF NOT EXISTS memories (
   status       TEXT NOT NULL DEFAULT 'active',
   tags         TEXT NOT NULL DEFAULT '',
   aliases      TEXT NOT NULL DEFAULT '',
+  alias        TEXT NOT NULL DEFAULT '',
+  target       TEXT NOT NULL DEFAULT '',
   content      TEXT NOT NULL,
   cjk          TEXT NOT NULL DEFAULT '',
   content_hash TEXT NOT NULL DEFAULT '',
@@ -103,7 +105,7 @@ END;
 `;
 
 /** Current index schema version. Bump when TABLE_SCHEMA/FTS_SCHEMA change. */
-const SCHEMA_VERSION = 7;
+const SCHEMA_VERSION = 8;
 
 function userVersion(d: AnyDatabase): number {
   const row = d.prepare("PRAGMA user_version").get() as { user_version: number };

package/src/store/lifecycle.ts

@@ -260,6 +260,9 @@ export interface SupersedeInput {
   type?: string;
   tags?: string[];
   aliases?: string[];
+  /** D81: undefined = inherit the old memory's pair. */
+  alias?: string;
+  target?: string;
   source?: string;
 }
 
@@ -288,6 +291,9 @@ export function supersede(
     tags: input.tags ?? oldMf.fm.tags,
     // D61: aliases carry forward unless the caller replaces them.
     aliases: input.aliases ?? oldMf.fm.aliases,
+    // D81: alias vocabulary carries forward the same way.
+    alias: input.alias ?? oldMf.fm.alias,
+    target: input.target ?? oldMf.fm.target,
     source: input.source ?? oldMf.fm.source,
     status: "active",
     created_at: now,

package/src/store/markdown.ts

@@ -60,6 +60,17 @@ export interface Frontmatter {
    * Optional and additive: files without it parse unchanged.
    */
   aliases?: string[];
+  /**
+   * D81: user-defined alias vocabulary — `alias` is the nickname
+   * (e.g. 香蕉计划), `target` is what it refers to
+   * (e.g. 支付系统重构项目). Unlike D61 per-memory aliases (alternate
+   * phrasings of one memory), an alias memory defines vocabulary once and
+   * the query-time expansion (retrieve/alias-memory.ts) applies it to every
+   * search in its scope — no reindex when the alias changes. Optional;
+   * files without it parse unchanged.
+   */
+  alias?: string;
+  target?: string;
   source: string;
   created_at: string; // RFC 3339, never bare epoch (§3)
   updated_at: string; // RFC 3339
@@ -247,6 +258,13 @@ export function normalizeFrontmatter(
           return aliases.length > 0 ? { aliases } : {};
         })()
       : {}),
+    // D81: alias vocabulary — single trimmed strings, dropped when empty.
+    ...(typeof raw.alias === "string" && raw.alias.trim()
+      ? { alias: raw.alias.trim() }
+      : {}),
+    ...(typeof raw.target === "string" && raw.target.trim()
+      ? { target: raw.target.trim() }
+      : {}),
     source: typeof raw.source === "string" ? raw.source : "",
     created_at: msToRfc3339(timeToMs(raw.created_at)),
     updated_at: msToRfc3339(timeToMs(raw.updated_at)),

package/src/store/sync.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { db } from "./db.ts";
 import { cjkIndexText } from "../retrieve/cjk.ts";
+import { expansionVariantsForDoc } from "../retrieve/synonyms.ts";
 import { contentHash, repairChain } from "./lifecycle.ts";
 import {
   iterMemoryFiles,
@@ -14,8 +15,8 @@ import { projectRoot, paths } from "../paths.ts";
 import { loadConfig } from "../config.ts";
 
 const UPSERT_SQL = `
-  INSERT INTO memories (id, scope_key, scope, visibility, project_name, type, role, importance, status, tags, aliases, content, cjk, content_hash, superseded_by, source, file_path, mtime_ms, created_at, updated_at, review_state)
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  INSERT INTO memories (id, scope_key, scope, visibility, project_name, type, role, importance, status, tags, aliases, alias, target, content, cjk, content_hash, superseded_by, source, file_path, mtime_ms, created_at, updated_at, review_state)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   ON CONFLICT(id) DO UPDATE SET
     scope_key    = excluded.scope_key,
     scope        = excluded.scope,
@@ -27,6 +28,8 @@ const UPSERT_SQL = `
     status       = excluded.status,
     tags         = excluded.tags,
     aliases      = excluded.aliases,
+    alias        = excluded.alias,
+    target       = excluded.target,
     content      = excluded.content,
     cjk          = excluded.cjk,
     content_hash = excluded.content_hash,
@@ -63,7 +66,17 @@ export function upsertFromFile(mf: MemoryFile): void {
 function writeRow(mf: MemoryFile, mtimeMs: number): void {
   const { fm, body, filePath } = mf;
   const tags = (fm.tags ?? []).join(",");
-  const aliases = (fm.aliases ?? []).join(",");
+  // D80 index-time expansion: curated synonym/translation variants for the
+  // memory's keywords are indexed in the aliases column (and therefore the
+  // CJK bigram column below), so any related word matches in round one.
+  // Derived at sync time — the Markdown file stays the source of truth.
+  const supplied = fm.aliases ?? [];
+  const have = new Set(supplied.map((a) => a.toLowerCase()));
+  const auto = expansionVariantsForDoc(body + "\n" + tags).filter(
+    (a) => !have.has(a.toLowerCase()),
+  );
+  const aliases = [...supplied, ...auto].join(",");
+  // D81: user-defined alias vocabulary (single nickname → referent pair).
   db().prepare(UPSERT_SQL).run(
     fm.id,
     fm.scope_key,
@@ -76,6 +89,8 @@ function writeRow(mf: MemoryFile, mtimeMs: number): void {
     fm.status,
     tags,
     aliases,
+    fm.alias ?? "",
+    fm.target ?? "",
     body,
     cjkIndexText(body + "\n" + tags + "\n" + aliases),
     contentHash(body),

package/src/tools/ops.ts

@@ -113,6 +113,18 @@ export const memoryAddArgs = {
   scope: scopeArg,
   tags: z.array(z.string()).optional().describe("Optional tags for filtering."),
   aliases: aliasesArg,
+  alias: z
+    .string()
+    .optional()
+    .describe(
+      "D81: nickname this memory defines (e.g. 香蕉计划). Pairs with `target`: the alias memory expands queries in its scope at search time, both directions, no reindex. Explicit vocabulary — always stored, not gated by capture aliases.",
+    ),
+  target: z
+    .string()
+    .optional()
+    .describe(
+      "D81: what `alias` refers to (e.g. 支付系统重构项目). Only meaningful with `alias`.",
+    ),
   source: z
     .string()
     .optional()
@@ -163,6 +175,18 @@ export const memorySupersedeArgs = {
     .describe("Category of the new memory. Defaults to the old memory's type."),
   tags: z.array(z.string()).optional().describe("Optional tags for the new memory."),
   aliases: aliasesArg,
+  alias: z
+    .string()
+    .optional()
+    .describe(
+      "D81: nickname the new memory defines (e.g. 香蕉计划). Omitted = inherit the old memory's alias.",
+    ),
+  target: z
+    .string()
+    .optional()
+    .describe(
+      "D81: what `alias` refers to (e.g. 支付系统重构项目). Omitted = inherit.",
+    ),
 };
 export type MemorySupersedeArgs = z.infer<z.ZodObject<typeof memorySupersedeArgs>>;
 
@@ -242,6 +266,8 @@ function buildFrontmatter(
     type: Frontmatter["type"];
     tags: string[];
     aliases?: string[];
+    alias?: string;
+    target?: string;
     source: Frontmatter["source"];
   },
 ): Frontmatter {
@@ -259,6 +285,11 @@ function buildFrontmatter(
     status: "active",
     tags: body.tags,
     ...(body.aliases && body.aliases.length > 0 ? { aliases: body.aliases } : {}),
+    // D81: explicit alias vocabulary — single trimmed strings, dropped
+    // when empty. Not gated by captureAliases (that gates agent-invented
+    // phrasings; this is deliberate vocabulary).
+    ...(body.alias?.trim() ? { alias: body.alias.trim() } : {}),
+    ...(body.target?.trim() ? { target: body.target.trim() } : {}),
     source: body.source,
     created_at: rfc,
     updated_at: rfc,
@@ -328,6 +359,14 @@ export async function addMemory(
           (args.aliases ?? []).map((a) => redact(a, cfg.redactPatterns).content),
         )
       : [],
+    // D81: explicit alias vocabulary — same redaction as content, never
+    // gated by captureAliases.
+    alias: args.alias?.trim()
+      ? redact(args.alias.trim(), cfg.redactPatterns).content
+      : undefined,
+    target: args.target?.trim()
+      ? redact(args.target.trim(), cfg.redactPatterns).content
+      : undefined,
     source: args.source ?? "tool",
   });
   const { filePath } = writeMemoryFile(fm, redacted);
@@ -447,6 +486,16 @@ export async function supersedeMemory(
               args.aliases.map((a) => redact(a, cfg.redactPatterns).content),
             )
           : undefined,
+      // D81: explicit alias vocabulary — omitted inherits the old memory's
+      // pair; same redaction as content; never gated by captureAliases.
+      alias:
+        args.alias !== undefined
+          ? redact(args.alias, cfg.redactPatterns).content || undefined
+          : undefined,
+      target:
+        args.target !== undefined
+          ? redact(args.target, cfg.redactPatterns).content || undefined
+          : undefined,
       source: "tool",
     });
     upsertFromFile(oldMf);