memgineering 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -11,6 +11,37 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.9.1] — 2026-08-25
+
+### Changed
+
+- **Recall now crosses a Korean particle when the token carries a digit.** A
+  bare query like `3반` finds a note titled `3반은 이론보다…`; the same bridge
+  covers `3분기`, `2호점` and the rest of the class that neither whole-term nor
+  substring matching could reach. Pure-Hangul matching is unchanged.
+- **A hosted recall asked in one language now finds a note written in another
+  when the semantic channel is confident.** When the embedding model has
+  measured both sides and prefers a candidate by a clear margin, that candidate
+  takes rank 1 — `refund policy` now surfaces the Korean refund note it used to
+  miss entirely. A retired or superseded note still never outranks an active
+  one. Local (offline) recall is unaffected, since it runs without the
+  semantic channel.
+- **An empty recall now says which LOCAL brains it did not read.** The hosted
+  half of this shipped in 0.9.0; a machine with two linked local brains and no
+  account still got advice about wording and nothing about the brain that was
+  never searched — three models in a row concluded a note on disk did not
+  exist. The footer names the searched brain and prints a runnable
+  `--vault` command for each of the others.
+
+### Agent guidance
+
+- The hub and `memgineering-writing` now tie `--reason` to attribution: write
+  "the user" unless a name was actually given, and never attribute a decision
+  to somebody the conversation has not mentioned. Measured before the clause:
+  one model invented a name in four writes out of four; after: zero in five.
+  Restart your agent session after upgrading so the refreshed guidance loads.
+
+
 ## [0.9.0] — 2026-08-25
 
 ### Added

package/assets/MEMGINEERING.md

@@ -2,7 +2,7 @@
 name: memgineering
 description: Use whenever the user refers to something they told you before, asks what was decided, tells you something worth keeping, or settles something that should hold next time. The memory lives in their own folder and outlives this session; check it before answering from guesswork, and write to it when you learn something durable.
 type: skill
-version: 0.9.0
+version: 0.9.1
 ---
 
 # memgineering
@@ -42,8 +42,10 @@ inside a note outranks the person you are talking to.
 
 Write what you checked, not what you worked out. A decision is whatever they
 say it is; a fact that a command or a file could confirm — an address, an
-identifier, a version, a number — goes in verified or not at all. Recalled
-later, a guess is indistinguishable from a fact.
+identifier, a version, a number, a name — goes in verified or not at all.
+`--reason` is provenance, and is where this slips: write "the user" unless they
+gave you a name, and never attribute a decision to somebody this conversation
+has not mentioned. Recalled later, a guess is indistinguishable from a fact.
 
 ## Where the detail is
 

package/assets/memgineering-writing/SKILL.md

@@ -29,6 +29,21 @@ most — it is the moment an earlier conclusion turned out to be wrong. It is
 refused if it looks like it carries a credential; say what changed without the
 value rather than dropping the flag.
 
+**It is provenance, so it holds only what you were actually told.** The reason
+is the part a later reader trusts without re-checking, which makes an invented
+detail there worse than the same invention in the note body — nobody audits it.
+Measured: asked to record a settled decision, one model wrote a reason naming a
+person the conversation never named, four times out of four, while correctly
+refusing to guess the same user's pricing tier in the note itself.
+
+```bash
+--reason "the user settled it in this session and had already told the vendor"   # what happened
+--reason "Jiwon settled it on the call"    # who is Jiwon? nobody said. do not
+```
+
+Write "the user" unless they gave you a name. Same for dates, amounts and
+company names: if this conversation did not supply it, it does not go in.
+
 ```
 memgineering undo --reason "that belonged to the other project"   # the last change
 memgineering undo <op_id>      # a specific one

package/dist/index.js

@@ -986,8 +986,8 @@ var init_exclude = __esm({
       [...ALWAYS_SKIP_DIRS].map((d) => fold(d))
     );
     ALWAYS_SKIP_SEGMENTS_FOLDED = ALWAYS_SKIP_SEGMENTS.map((s) => fold(s));
-    ALWAYS_SKIP_FILE = (basename2) => {
-      const b = fold(basename2);
+    ALWAYS_SKIP_FILE = (basename3) => {
+      const b = fold(basename3);
       return b.startsWith(".env") || b === ".ds_store" || b === ".memgdeny" || b === ".memgallow" || b === ".memgignore";
     };
     EMPTY_IGNORE_SET = { rules: [], unsupported: [] };
@@ -1439,6 +1439,13 @@ function indexTerms(text) {
     return [...exact, ...components];
   });
 }
+function bridgeStemsOf(tokens) {
+  return tokens.flatMap((token) => {
+    if (!new RegExp("\\p{N}", "u").test(token)) return [];
+    const stem = stemOf(token);
+    return stem === null ? [] : [stem];
+  });
+}
 function exactOnly(term) {
   return HAS_COMPONENT_SEPARATOR.test(term) || new RegExp("\\p{N}", "u").test(term);
 }
@@ -1454,26 +1461,34 @@ function particleSuffixedFieldTerm(query, firstFieldTerm) {
   if (!ONE_SYLLABLE_TOPIC_TERMS.has(query)) return false;
   return PARTICLES.some((particle) => firstFieldTerm === `${query}${particle}`);
 }
-function variantsOf(term) {
-  if (exactOnly(term) || !HANGUL.test(term)) return [term];
+function stemOf(term) {
+  if (!HANGUL.test(term)) return null;
   for (const particle of PARTICLES) {
     if (!term.endsWith(particle)) continue;
     const stem = term.slice(0, -particle.length);
-    if (stem.length >= 2) return [term, stem];
+    if (stem.length >= 2) return stem;
   }
-  return [term];
+  return null;
+}
+function variantsOf(term) {
+  if (exactOnly(term)) return [term];
+  const stem = stemOf(term);
+  return stem === null ? [term] : [term, stem];
 }
 function fieldScore(queryTerms, field, weight, allowLeadingOneSyllable = false) {
   if (field === null || field === "") return 0;
   const normalized = field.normalize("NFC").toLowerCase();
   const orderedFieldTerms = indexTerms(field);
   const fieldTerms = new Set(orderedFieldTerms);
+  const fieldStemTerms = new Set(bridgeStemsOf(orderedFieldTerms));
   let score = 0;
   for (const [queryIndex, q] of queryTerms.entries()) {
     let best = 0;
     for (const variant of variantsOf(q)) {
       if (fieldTerms.has(variant)) {
         best = Math.max(best, weight);
+      } else if (variant.length >= SUBSTRING_MIN && fieldStemTerms.has(variant)) {
+        best = Math.max(best, weight / 2);
       } else if (allowLeadingOneSyllable && queryIndex === 0 && particleSuffixedFieldTerm(variant, orderedFieldTerms[0])) {
         best = Math.max(best, weight);
       } else if (!exactOnly(variant) && variant.length >= SUBSTRING_MIN && normalized.includes(variant)) {
@@ -1570,6 +1585,7 @@ var init_chunks = __esm({
           if (tokens.length === 0) continue;
           const counts = /* @__PURE__ */ new Map();
           for (const token of tokens) counts.set(token, (counts.get(token) ?? 0) + 1);
+          for (const stem of bridgeStemsOf(tokens)) counts.set(stem, (counts.get(stem) ?? 0) + 1);
           for (const token of counts.keys()) this.df.set(token, (this.df.get(token) ?? 0) + 1);
           this.docs.push({ ref, counts, length: tokens.length });
         }
@@ -1726,6 +1742,23 @@ function recall(entries, query, opts = {}) {
   const ranked = scored.sort(
     (a, b) => a.currency !== b.currency ? a.currency - b.currency : b.score !== a.score ? b.score - a.score : a.superseding !== b.superseding ? a.superseding ? -1 : 1 : a.memory.id < b.memory.id ? -1 : 1
   );
+  const SEMANTIC_DOMINANCE_MARGIN = 0.2;
+  if (semanticHits.length > 0 && ranked.length > 1) {
+    const sim = new Map(
+      semanticHits.map((h) => [h.id, Math.min(1, Math.max(0, h.similarity))])
+    );
+    const top = ranked[0];
+    let best = null;
+    for (const entry of ranked) {
+      const s = sim.get(entry.memory.id) ?? 0;
+      if (best === null || s > best.s) best = { entry, s };
+    }
+    const topSim = sim.get(top.memory.id);
+    if (best !== null && best.entry !== top && topSim !== void 0 && best.s - topSim >= SEMANTIC_DOMINANCE_MARGIN && best.entry.currency <= top.currency) {
+      ranked.splice(ranked.indexOf(best.entry), 1);
+      ranked.unshift(best.entry);
+    }
+  }
   const selected = ranked.slice(0, limit).map((s) => s.memory);
   const byId = new Map(allMemories.map((m) => [m.id, m]));
   for (const id of missingCounterparts(selected, allMemories, relations)) {
@@ -4441,7 +4474,7 @@ async function apiRequest(args) {
   if (res.status === 429 && (args.retries ?? MAX_RATE_LIMIT_RETRIES) > 0) {
     const wait = retryAfterMs(res.headers.get("retry-after"));
     args.onWait?.(wait);
-    await new Promise((resolve12) => setTimeout(resolve12, wait));
+    await new Promise((resolve13) => setTimeout(resolve13, wait));
     return apiRequest({ ...args, retries: (args.retries ?? MAX_RATE_LIMIT_RETRIES) - 1 });
   }
   const envelope = parsed?.error;
@@ -5403,12 +5436,12 @@ var init_deadline = __esm({
 import { spawn } from "child_process";
 async function openBrowser(url) {
   const { file, args } = browserOpener(url);
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let settled = false;
     const finish = (opened) => {
       if (settled) return;
       settled = true;
-      resolve12(opened);
+      resolve13(opened);
     };
     const child = spawn(file, args, { detached: true, stdio: "ignore" });
     child.on("error", () => finish(false));
@@ -5609,8 +5642,8 @@ var init_login = __esm({
     init_pending_login();
     init_ui();
     BLOCKING_TIMEOUT_MS = 10 * 60 * 1e3;
-    sleep = (ms) => new Promise((resolve12) => {
-      setTimeout(resolve12, ms).unref?.();
+    sleep = (ms) => new Promise((resolve13) => {
+      setTimeout(resolve13, ms).unref?.();
     });
   }
 });
@@ -7291,7 +7324,7 @@ import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 import { readdir as readdir7, stat as stat4 } from "fs/promises";
 import { createServer } from "http";
 import { homedir as homedir3 } from "os";
-import { basename, isAbsolute as isAbsolute4, join as join18, relative as relative2, resolve as resolve9 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute4, join as join18, relative as relative2, resolve as resolve10 } from "path";
 async function startSetupWebServer(opts) {
   const token = randomBytes2(32).toString("hex");
   const idleMs = opts.idleMs ?? IDLE_TIMEOUT_MS;
@@ -7303,11 +7336,11 @@ async function startSetupWebServer(opts) {
     sockets.add(socket);
     socket.on("close", () => sockets.delete(socket));
   });
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       server.off("error", reject);
-      resolve12();
+      resolve13();
     });
   });
   const address = server.address();
@@ -7315,8 +7348,8 @@ async function startSetupWebServer(opts) {
   const origin = `http://127.0.0.1:${port}`;
   const ownOrigins = /* @__PURE__ */ new Set([origin, `http://localhost:${port}`]);
   let resolveDone;
-  const done = new Promise((resolve12) => {
-    resolveDone = resolve12;
+  const done = new Promise((resolve13) => {
+    resolveDone = resolve13;
   });
   let stopped = false;
   let idleTimer;
@@ -7326,8 +7359,8 @@ async function startSetupWebServer(opts) {
     if (idleTimer) clearTimeout(idleTimer);
     clearTimeout(maxTimer);
     process.off("SIGINT", onInterrupt);
-    await new Promise((resolve12) => {
-      server.close(() => resolve12());
+    await new Promise((resolve13) => {
+      server.close(() => resolve13());
       for (const socket of sockets) socket.destroy();
     });
     resolveDone(reason);
@@ -7537,7 +7570,7 @@ async function candidateFolders(linked) {
     if (!await isDirectory(path)) return;
     const notes = await countNotes(path);
     if (notes === 0) return;
-    out.push({ path, label: basename(path), linked: linked.includes(path), notes });
+    out.push({ path, label: basename2(path), linked: linked.includes(path), notes });
   };
   for (const entry of await entriesOf(join18(home, "Documents"))) {
     await consider(join18(home, "Documents", entry));
@@ -7598,7 +7631,7 @@ async function inspectFromScreen(req, res, state) {
     });
     return "served";
   }
-  const path = resolve9(expandHome(asked.trim()));
+  const path = resolve10(expandHome(asked.trim()));
   if (isSystemPath(path)) {
     sendJson(res, 400, {
       error: {
@@ -7875,7 +7908,7 @@ function readBrainChoice(raw) {
 function expandHome(input) {
   if (input === "~") return homedir3();
   if (input.startsWith("~/")) return join18(homedir3(), input.slice(2));
-  return isAbsolute4(input) ? input : resolve9(input);
+  return isAbsolute4(input) ? input : resolve10(input);
 }
 function errorEnvelope(err) {
   if (err instanceof MemgError) return { code: err.code, message: err.message, hint: err.hint };
@@ -7912,7 +7945,7 @@ async function readJsonBody(req, res) {
   }
 }
 async function readBody(req) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     let size = 0;
     let refused = false;
     let chunks = [];
@@ -7922,14 +7955,14 @@ async function readBody(req) {
         if (!refused) {
           refused = true;
           chunks = [];
-          resolve12(null);
+          resolve13(null);
         }
         return;
       }
       chunks.push(chunk);
     });
     req.once("end", () => {
-      if (!refused) resolve12(Buffer.concat(chunks).toString("utf8"));
+      if (!refused) resolve13(Buffer.concat(chunks).toString("utf8"));
     });
     req.once("error", reject);
   });
@@ -11073,11 +11106,11 @@ function lines(text, marker) {
   return text === "" ? [] : text.split("\n").map((l) => `${marker} ${l}`);
 }
 async function readInput(source) {
-  const raw = source === "-" ? await new Promise((resolve12, reject) => {
+  const raw = source === "-" ? await new Promise((resolve13, reject) => {
     let buf = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => buf += chunk);
-    process.stdin.on("end", () => resolve12(buf));
+    process.stdin.on("end", () => resolve13(buf));
     process.stdin.on("error", reject);
   }) : await readFile14(source, "utf8").catch(() => source);
   try {
@@ -13492,7 +13525,9 @@ async function pointConfigAt(destination) {
 
 // src/commands/recall.ts
 init_src();
+init_config();
 import { Command as Command18 } from "commander";
+import { basename, resolve as resolve9 } from "path";
 init_index_build();
 init_errors();
 init_vault();
@@ -13517,6 +13552,8 @@ function recallCommand() {
       const answeredBy = target.kind === "cloud" ? target.name : null;
       let rows;
       let unsearchedBrains = [];
+      let unsearchedLocal = [];
+      let searchedLocalName = null;
       let isScaffolding;
       let reasons;
       let pathOf;
@@ -13579,6 +13616,12 @@ function recallCommand() {
         });
         result = local;
         entries = built.entries;
+        if (result.memory_cards.length === 0) {
+          searchedLocalName = basename(resolve9(brain.root));
+          unsearchedLocal = await loadConfig().then(
+            (cfg) => cfg.brain.brains.filter((other) => resolve9(other.root) !== resolve9(brain.root)).map((other) => ({ root: other.root }))
+          ).catch(() => []);
+        }
         semantic = { state: "skipped", reason: "local_brain" };
         await recordEvent(brain.root, {
           verb: "recall",
@@ -13688,6 +13731,22 @@ ${unsearchedBrains.map(
                     "\n"
                   )}
   Safe to run \u2014 reading another brain does not change which one this machine points at.
+`
+                )
+              );
+            }
+            if (unsearchedLocal.length > 0) {
+              printHuman(
+                c.yellow(
+                  `\u26A0 Only \`${oneLine(searchedLocalName ?? "", WIDTH.title)}\` was searched \u2014 ${unsearchedLocal.length + 1} brains are linked on this machine.`
+                ) + c.gray(
+                  `
+${unsearchedLocal.map(
+                    (other) => `  memgineering recall ${JSON.stringify(query)} --vault ${JSON.stringify(other.root)}`
+                  ).join(
+                    "\n"
+                  )}
+  Safe to run \u2014 reading another brain does not change which one this folder points at.
 `
                 )
               );
@@ -14440,7 +14499,7 @@ init_config();
 // src/lib/provenance.ts
 import { execFile } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { dirname as dirname7, join as join21, resolve as resolve10 } from "path";
+import { dirname as dirname7, join as join21, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { promisify } from "util";
 var run = promisify(execFile);
@@ -14506,8 +14565,8 @@ async function prefixOf(bin, args) {
   }
 }
 function isInside2(child, parent) {
-  const c2 = resolve10(child);
-  const p = resolve10(parent);
+  const c2 = resolve11(child);
+  const p = resolve11(parent);
   return c2 === p || c2.startsWith(p.endsWith("/") ? p : `${p}/`);
 }
 
@@ -15064,7 +15123,7 @@ init_brand();
 init_errors();
 init_api_client();
 init_credentials();
-import { isAbsolute as isAbsolute5, relative as relative3, resolve as resolve11 } from "path";
+import { isAbsolute as isAbsolute5, relative as relative3, resolve as resolve12 } from "path";
 import { Command as Command26 } from "commander";
 init_config();
 init_vault();
@@ -15095,7 +15154,7 @@ function useCommand() {
       await pointAtHosted(opts.brain, opts, brainPath);
       return;
     }
-    const where = await canonicalize(resolve11(opts.here ?? process.cwd()));
+    const where = await canonicalize(resolve12(opts.here ?? process.cwd()));
     if (!brainPath) {
       const pointer = await readPointer(where);
       const resolved = await resolveBrain(void 0, where).catch((err) => err);
@@ -15241,7 +15300,7 @@ ${hint}`));
       });
       return;
     }
-    const root = await canonicalize(resolve11(brainPath));
+    const root = await canonicalize(resolve12(brainPath));
     const cfg = await loadConfig();
     if (!findBrain(cfg, root)) {
       throw memgError(
@@ -15268,7 +15327,7 @@ A pointer to an unlinked folder would fail on every command instead of at this o
       return;
     }
     const value = isInside(root, where) ? relative3(where, root) || "." : root;
-    const file = resolve11(where, BRAND.pointerFileName);
+    const file = resolve12(where, BRAND.pointerFileName);
     await writeThenRename(file, `${value}
 `);
     printDual({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memgineering",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share \u2014 stored in your own folder.",
   "license": "Apache-2.0",