@hiveai/cli 0.2.5 → 0.2.7

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -54,7 +54,7 @@ function registerBriefing(program2) {
     "--scope <scope>",
     "personal | team | module | all (default: team)",
     "team"
-  ).option("--include-draft", "include draft memories (excluded by default)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--include-draft", "include draft memories (excluded by default)").option("--include-stale", "include stale memories (excluded by default \u2014 may be outdated)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
     if (existsSync(paths.projectContext)) {
@@ -78,6 +78,7 @@ function registerBriefing(program2) {
       const fm = mem.frontmatter;
       if (fm.status === "rejected" || fm.status === "deprecated") return false;
       if (!opts.includeDraft && fm.status === "draft") return false;
+      if (!opts.includeStale && fm.status === "stale") return false;
       if (scopeFilter !== "all" && fm.scope !== scopeFilter) return false;
       return true;
     });
@@ -108,8 +109,9 @@ function registerBriefing(program2) {
       const fm = mem.frontmatter;
       const badge = ui.statusBadge(fm.status);
       const draftMarker = fm.status === "draft" ? ui.yellow(" [DRAFT]") : "";
+      const unverifiedMarker = fm.status === "proposed" ? ui.yellow(" [UNVERIFIED]") : "";
       console.log(
-        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}`
+        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}`
       );
       console.log(mem.body.trim());
       console.log();
@@ -418,9 +420,9 @@ function locateMcpBin() {
 
 // src/commands/sync.ts
 import { spawnSync } from "child_process";
-import { writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import "path";
+import path6 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
@@ -433,11 +435,16 @@ import {
   serializeMemory,
   verifyAnchor
 } from "@hiveai/core";
+var BRIDGE_START = "<!-- haive:memories-start -->";
+var BRIDGE_END = "<!-- haive:memories-end -->";
 function registerSync(program2) {
   program2.command("sync").description("Refresh memory state after a pull/merge: verify anchors, auto-promote, report changes").option("-d, --dir <dir>", "project root").option("--quiet", "minimal output (suitable for git hooks)").option(
     "--since <ref>",
     "git ref/commit to compare against; report memories added/modified/removed since"
-  ).option("--no-verify", "skip the anchor verification step").option("--no-promote", "skip the auto-promotion step").action(async (opts) => {
+  ).option("--no-verify", "skip the anchor verification step").option("--no-promote", "skip the auto-promotion step").option(
+    "--inject-bridge",
+    "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
+  ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").action(async (opts) => {
     const root = findProjectRoot8(opts.dir);
     const paths = resolveHaivePaths5(root);
     if (!existsSync6(paths.memoriesDir)) {
@@ -529,6 +536,11 @@ function registerSync(program2) {
         )
       );
     }
+    if (opts.injectBridge) {
+      const bridgeFile = opts.bridgeFile ? path6.resolve(opts.bridgeFile) : path6.join(root, "CLAUDE.md");
+      const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
+      await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
+    }
     if (sinceReport && !opts.quiet) {
       if (sinceReport.added.length > 0) {
         log(ui.bold("\nNew memories:"));
@@ -545,6 +557,60 @@ function registerSync(program2) {
     }
   });
 }
+async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
+  if (!existsSync6(memoriesDir)) return;
+  const all = await loadMemoriesFromDir2(memoriesDir);
+  const top = all.filter(({ memory: memory2 }) => {
+    const s = memory2.frontmatter.status;
+    return s === "validated" || s === "proposed";
+  }).sort((a, b) => {
+    const score = (m) => {
+      const s = m.memory.frontmatter.status;
+      return s === "validated" ? 2 : 1;
+    };
+    return score(b) - score(a);
+  }).slice(0, maxMemories);
+  const block = top.map((m) => {
+    const fm = m.memory.frontmatter;
+    const unverified = fm.status === "proposed" ? " [UNVERIFIED]" : "";
+    return `### ${fm.id} (${fm.scope}/${fm.type})${unverified}
+${m.memory.body.trim()}`;
+  }).join("\n\n---\n\n");
+  const injected = `${BRIDGE_START}
+<!-- AUTO-GENERATED by haive sync --inject-bridge \u2014 do not edit between these markers -->
+
+` + block + `
+
+${BRIDGE_END}`;
+  const fileExists = existsSync6(bridgeFile);
+  let existing = fileExists ? await readFile3(bridgeFile, "utf8") : "";
+  existing = existing.replace(/\r\n/g, "\n");
+  const startIdx = existing.indexOf(BRIDGE_START);
+  const endIdx = existing.indexOf(BRIDGE_END);
+  if (startIdx !== -1 && endIdx === -1) {
+    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    return;
+  }
+  if (startIdx === -1 && endIdx !== -1) {
+    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    return;
+  }
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
+  } else {
+    if (!fileExists && !quiet) {
+      ui.info(`Creating ${path6.relative(root, bridgeFile)} with haive memory block.`);
+    }
+    updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
+  }
+  await writeFile3(bridgeFile, updated, "utf8");
+  if (!quiet) {
+    console.log(
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path6.relative(root, bridgeFile)}`)
+    );
+  }
+}
 function collectSinceChanges(root, ref) {
   const result = spawnSync(
     "git",
@@ -565,7 +631,7 @@ function collectSinceChanges(root, ref) {
 }
 
 // src/commands/memory-add.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import path7 from "path";
 import "commander";
@@ -573,12 +639,13 @@ import {
   buildFrontmatter,
   findProjectRoot as findProjectRoot9,
   inferModulesFromPaths,
+  loadMemoriesFromDir as loadMemoriesFromDir3,
   memoryFilePath,
   resolveHaivePaths as resolveHaivePaths6,
   serializeMemory as serializeMemory2
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
-  memory2.command("add").description("Add a new memory (defaults to personal scope)").requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary").requiredOption("--slug <slug>", "short identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor paths, comma-separated").option("--symbols <csv>", "anchor symbols, comma-separated").option("--commit <sha>", "anchor commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  memory2.command("add").description("Add a new memory (defaults to personal scope)").requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor paths, comma-separated").option("--symbols <csv>", "anchor symbols, comma-separated").option("--commit <sha>", "anchor commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 alternative to --body for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot9(opts.dir);
     const paths = resolveHaivePaths6(root);
     if (!existsSync7(paths.haiveDir)) {
@@ -605,7 +672,18 @@ function registerMemoryAdd(memory2) {
     });
     const title = opts.title ?? opts.slug;
     let body;
-    if (opts.body !== void 0) {
+    if (opts.bodyFile !== void 0) {
+      if (!existsSync7(opts.bodyFile)) {
+        ui.error(`--body-file not found: ${opts.bodyFile}`);
+        process.exitCode = 1;
+        return;
+      }
+      const fileContent = await readFile4(opts.bodyFile, "utf8");
+      body = opts.title ? `# ${opts.title}
+
+${fileContent.trim()}
+` : fileContent;
+    } else if (opts.body !== void 0) {
       body = opts.title ? `# ${opts.title}
 
 ${opts.body}` : opts.body;
@@ -622,6 +700,18 @@ TODO \u2014 write the memory body.
       process.exitCode = 1;
       return;
     }
+    if (existsSync7(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir3(paths.memoriesDir);
+      const slugTokens = opts.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
+      const similar = existing.filter(({ memory: memory3 }) => {
+        const id = memory3.frontmatter.id.toLowerCase();
+        return slugTokens.length >= 2 && slugTokens.filter((t) => id.includes(t)).length >= Math.ceil(slugTokens.length * 0.6);
+      });
+      if (similar.length > 0) {
+        ui.warn(`Possible duplicate \u2014 similar memories exist: ${similar.map((m) => m.memory.frontmatter.id).join(", ")}`);
+        ui.warn("Consider updating one of these with `haive memory update` instead.");
+      }
+    }
     await writeFile4(file, serializeMemory2({ frontmatter, body }), "utf8");
     ui.success(`Created ${path7.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
@@ -654,7 +744,7 @@ import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaive
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir3,
+  loadMemoriesFromDir as loadMemoriesFromDir4,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -669,7 +759,7 @@ function registerMemoryList(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
     const filtered = all.filter((m) => {
       if (!matchesFilters(m, opts)) return false;
@@ -750,7 +840,7 @@ function registerMemoryPromote(memory2) {
       process.exitCode = 1;
       return;
     }
-    const teamAndModule = await loadMemoriesFromDir3(paths.memoriesDir);
+    const teamAndModule = await loadMemoriesFromDir4(paths.memoriesDir);
     const alreadyShared = teamAndModule.find(
       (m) => m.memory.frontmatter.id === id && (m.memory.frontmatter.scope === "team" || m.memory.frontmatter.scope === "module")
     );
@@ -764,7 +854,7 @@ function registerMemoryPromote(memory2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.personalDir);
+    const all = await loadMemoriesFromDir4(paths.personalDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No personal memory with id "${id}". (Promotion only applies to personal scope.)`);
@@ -808,7 +898,7 @@ function registerMemoryApprove(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     if (opts.all || opts.pending) {
       const candidates = all.filter((m) => {
         const s = m.memory.frontmatter.status;
@@ -879,7 +969,7 @@ function registerMemoryUpdate(memory2) {
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir3(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir4(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -975,7 +1065,7 @@ function registerMemoryAutoPromote(memory2) {
       minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE2.minReads),
       maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE2.maxRejections)
     };
-    const memories = await loadMemoriesFromDir3(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir4(paths.memoriesDir);
     const usage = await loadUsageIndex2(paths);
     const eligible = memories.filter(
       ({ memory: memory3 }) => isAutoPromoteEligible2(memory3.frontmatter, getUsage2(usage, memory3.frontmatter.id), rule)
@@ -1010,7 +1100,7 @@ function registerMemoryAutoPromote(memory2) {
 // src/commands/memory-edit.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import path13 from "path";
 import "commander";
 import {
@@ -1027,7 +1117,7 @@ function registerMemoryEdit(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -1041,7 +1131,7 @@ function registerMemoryEdit(memory2) {
       ui.warn(`Editor exited with status ${code}.`);
     }
     try {
-      const fresh = await readFile3(found.filePath, "utf8");
+      const fresh = await readFile5(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -1083,7 +1173,7 @@ function registerMemoryForFiles(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const usage = await loadUsageIndex3(paths);
     const inferred = inferModulesFromPaths2(files);
     const byAnchor = [];
@@ -1155,7 +1245,7 @@ function registerMemoryHot(memory2) {
       return;
     }
     const threshold = Math.max(1, Number(opts.threshold ?? 3));
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const usage = await loadUsageIndex4(paths);
     const candidates = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -1185,26 +1275,83 @@ function registerMemoryHot(memory2) {
   });
 }
 
-// src/commands/memory-pending.ts
+// src/commands/memory-tried.ts
+import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
 import path16 from "path";
 import "commander";
 import {
+  buildFrontmatter as buildFrontmatter2,
   findProjectRoot as findProjectRoot18,
+  memoryFilePath as memoryFilePath3,
+  resolveHaivePaths as resolveHaivePaths15,
+  serializeMemory as serializeMemory7
+} from "@hiveai/core";
+function registerMemoryTried(memory2) {
+  memory2.command("tried").description(
+    "Record a failed approach \u2014 negative knowledge to prevent repeated AI mistakes"
+  ).requiredOption("--what <text>", "what approach was tried").requiredOption("--why-failed <text>", "why it failed or should NOT be used").option("--instead <text>", "recommended alternative").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot18(opts.dir);
+    const paths = resolveHaivePaths15(root);
+    if (!existsSync16(paths.haiveDir)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const slug = opts.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
+    const baseFm = buildFrontmatter2({
+      type: "attempt",
+      slug,
+      scope: opts.scope,
+      module: opts.module,
+      tags: parseCsv4(opts.tags),
+      paths: parseCsv4(opts.paths),
+      author: opts.author
+    });
+    const frontmatter = { ...baseFm, status: "validated" };
+    const lines = [`# ${opts.what}`, ""];
+    lines.push(`**Why it failed / do NOT use:** ${opts.whyFailed}`);
+    if (opts.instead) {
+      lines.push("", `**Instead, use:** ${opts.instead}`);
+    }
+    const body = lines.join("\n") + "\n";
+    const file = memoryFilePath3(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    await mkdir5(path16.dirname(file), { recursive: true });
+    if (existsSync16(file)) {
+      ui.error(`Memory already exists at ${file}`);
+      process.exitCode = 1;
+      return;
+    }
+    await writeFile9(file, serializeMemory7({ frontmatter, body }), "utf8");
+    ui.success(`Recorded: ${path16.relative(root, file)}`);
+    ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
+  });
+}
+function parseCsv4(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+// src/commands/memory-pending.ts
+import { existsSync as existsSync17 } from "fs";
+import path17 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot19,
   getUsage as getUsage5,
   loadUsageIndex as loadUsageIndex5,
-  resolveHaivePaths as resolveHaivePaths15
+  resolveHaivePaths as resolveHaivePaths16
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List 'proposed' memories awaiting review (sorted by reads desc)").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot18(opts.dir);
-    const paths = resolveHaivePaths15(root);
-    if (!existsSync16(paths.memoriesDir)) {
+    const root = findProjectRoot19(opts.dir);
+    const paths = resolveHaivePaths16(root);
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const usage = await loadUsageIndex5(paths);
     const proposed = all.filter(({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed") return false;
@@ -1227,55 +1374,70 @@ function registerMemoryPending(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path16.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync17 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync18 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   extractSnippet,
-  findProjectRoot as findProjectRoot19,
+  findProjectRoot as findProjectRoot20,
   literalMatchesAllTokens as literalMatchesAllTokens2,
+  literalMatchesAnyToken,
   pickSnippetNeedle,
-  resolveHaivePaths as resolveHaivePaths16,
+  resolveHaivePaths as resolveHaivePaths17,
   tokenizeQuery as tokenizeQuery2
 } from "@hiveai/core";
 function registerMemoryQuery(memory2) {
-  memory2.command("query <text>").description("Search memories by id, tag, or substring (multi-word AND)").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
-    const root = findProjectRoot19(opts.dir);
-    const paths = resolveHaivePaths16(root);
-    if (!existsSync17(paths.memoriesDir)) {
+  memory2.command("query <text>").description("Search memories by id, tag, or substring (AND, OR fallback)").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
+    const root = findProjectRoot20(opts.dir);
+    const paths = resolveHaivePaths17(root);
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
     const tokens = tokenizeQuery2(text);
+    if (tokens.length === 0) {
+      ui.warn("Empty query \u2014 use `haive memory list` to list all memories.");
+      return;
+    }
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
-    const matches = all.filter(({ memory: mem }) => {
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
+    const passesFilters = (mem) => {
       const fm = mem.frontmatter;
       if (opts.scope && fm.scope !== opts.scope) return false;
       if (!opts.showRejected && !statusFilter && fm.status === "rejected") return false;
       if (statusFilter && !statusFilter.includes(fm.status)) return false;
-      return literalMatchesAllTokens2(mem, tokens);
-    });
+      return true;
+    };
+    const eligible = all.filter(({ memory: mem }) => passesFilters(mem));
+    let matches = eligible.filter(({ memory: mem }) => literalMatchesAllTokens2(mem, tokens));
+    let fallback = false;
+    if (matches.length === 0 && tokens.length > 1) {
+      matches = eligible.filter(({ memory: mem }) => literalMatchesAnyToken(mem, tokens));
+      fallback = true;
+    }
     const limit = Math.max(1, Number(opts.limit ?? 20));
     const top = matches.slice(0, limit);
     if (top.length === 0) {
       ui.info(`No matches for "${text}".`);
       return;
     }
+    if (fallback) {
+      ui.info(`No exact match \u2014 showing partial results (OR fallback):`);
+    }
     const snippetNeedle = pickSnippetNeedle(text);
     for (const { memory: mem, filePath } of top) {
       const fm = mem.frontmatter;
       const statusBadge = ui.statusBadge(fm.status);
       console.log(`${ui.bold(fm.id)} ${ui.dim(fm.scope)} ${statusBadge}`);
-      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path18.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -1287,36 +1449,36 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
+import { writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot20,
+  findProjectRoot as findProjectRoot21,
   loadUsageIndex as loadUsageIndex6,
   recordRejection,
-  resolveHaivePaths as resolveHaivePaths17,
+  resolveHaivePaths as resolveHaivePaths18,
   saveUsageIndex,
-  serializeMemory as serializeMemory7
+  serializeMemory as serializeMemory8
 } from "@hiveai/core";
 function registerMemoryReject(memory2) {
   memory2.command("reject <id>").description("Record a rejection (blocks auto-promotion and lowers confidence)").option("-r, --reason <reason>", "why this memory is being rejected").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot20(opts.dir);
-    const paths = resolveHaivePaths17(root);
-    if (!existsSync18(paths.memoriesDir)) {
+    const root = findProjectRoot21(opts.dir);
+    const paths = resolveHaivePaths18(root);
+    if (!existsSync19(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir3(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir4(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    await writeFile9(
+    await writeFile10(
       loaded.filePath,
-      serializeMemory7({
+      serializeMemory8({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -1338,34 +1500,34 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot21,
+  findProjectRoot as findProjectRoot22,
   loadUsageIndex as loadUsageIndex7,
-  resolveHaivePaths as resolveHaivePaths18,
+  resolveHaivePaths as resolveHaivePaths19,
   saveUsageIndex as saveUsageIndex2
 } from "@hiveai/core";
 function registerMemoryRm(memory2) {
   memory2.command("rm <id>").description("Delete a memory file (and its usage entry by default)").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot21(opts.dir);
-    const paths = resolveHaivePaths18(root);
-    if (!existsSync19(paths.memoriesDir)) {
+    const root = findProjectRoot22(opts.dir);
+    const paths = resolveHaivePaths19(root);
+    if (!existsSync20(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    const rel = path18.relative(root, found.filePath);
+    const rel = path19.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -1389,27 +1551,27 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import path19 from "path";
+import { existsSync as existsSync21 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import path20 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
-  findProjectRoot as findProjectRoot22,
+  findProjectRoot as findProjectRoot23,
   getUsage as getUsage6,
   loadUsageIndex as loadUsageIndex8,
-  resolveHaivePaths as resolveHaivePaths19
+  resolveHaivePaths as resolveHaivePaths20
 } from "@hiveai/core";
 function registerMemoryShow(memory2) {
   memory2.command("show <id>").description("Print a memory's frontmatter, body, and confidence/usage").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot22(opts.dir);
-    const paths = resolveHaivePaths19(root);
-    if (!existsSync20(paths.memoriesDir)) {
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
+    if (!existsSync21(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -1417,7 +1579,7 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile4(found.filePath, "utf8"));
+      console.log(await readFile6(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
@@ -1433,7 +1595,7 @@ function registerMemoryShow(memory2) {
     if (fm.verified_at) console.log(`${ui.dim("verified:")}   ${fm.verified_at}`);
     if (fm.stale_reason) console.log(`${ui.dim("stale:")}      ${fm.stale_reason}`);
     console.log(`${ui.dim("reads:")}      ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`);
-    console.log(`${ui.dim("file:")}       ${path19.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path20.relative(root, found.filePath)}`);
     if (fm.anchor.paths.length || fm.anchor.symbols.length) {
       console.log(ui.dim("anchor:"));
       if (fm.anchor.commit) console.log(`  ${ui.dim("commit:")}  ${fm.anchor.commit}`);
@@ -1448,26 +1610,26 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync21 } from "fs";
-import path20 from "path";
+import { existsSync as existsSync22 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
-  findProjectRoot as findProjectRoot23,
+  findProjectRoot as findProjectRoot24,
   getUsage as getUsage7,
   loadUsageIndex as loadUsageIndex9,
-  resolveHaivePaths as resolveHaivePaths20
+  resolveHaivePaths as resolveHaivePaths21
 } from "@hiveai/core";
 function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
-    if (!existsSync21(paths.memoriesDir)) {
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
+    if (!existsSync22(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const usage = await loadUsageIndex9(paths);
     const target = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (target.length === 0) {
@@ -1487,32 +1649,32 @@ function registerMemoryStats(memory2) {
       console.log(
         `  ${ui.dim("status:")} ${fm.status}  ${ui.dim("reads:")} ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`
       );
-      console.log(`  ${ui.dim(path20.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
-import path21 from "path";
+import { writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import path22 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot24,
-  resolveHaivePaths as resolveHaivePaths21,
-  serializeMemory as serializeMemory8,
+  findProjectRoot as findProjectRoot25,
+  resolveHaivePaths as resolveHaivePaths22,
+  serializeMemory as serializeMemory9,
   verifyAnchor as verifyAnchor2
 } from "@hiveai/core";
 function registerMemoryVerify(memory2) {
   memory2.command("verify").description("Check memory anchors against current code, optionally marking stale ones").option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale (or status=validated for re-freshed) back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
-    if (!existsSync22(paths.memoriesDir)) {
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
+    if (!existsSync23(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir3(paths.memoriesDir);
+    const all = await loadMemoriesFromDir4(paths.memoriesDir);
     const targets = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (opts.id && targets.length === 0) {
       ui.error(`No memory with id "${opts.id}".`);
@@ -1521,16 +1683,16 @@ function registerMemoryVerify(memory2) {
     }
     let staleCount = 0;
     let freshCount = 0;
-    let anchorless = 0;
+    const anchorlessIds = [];
     let updated = 0;
     for (const { memory: mem, filePath } of targets) {
       const result = await verifyAnchor2(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
       if (!isAnchored) {
-        anchorless++;
+        anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path21.relative(root, filePath);
+      const rel = path22.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -1542,17 +1704,26 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification(mem, result);
-        await writeFile10(filePath, serializeMemory8(next), "utf8");
+        await writeFile11(filePath, serializeMemory9(next), "utf8");
         updated++;
       }
     }
     const summary = [
       `${freshCount} fresh`,
       `${staleCount} stale`,
-      `${anchorless} anchorless (skipped)`
+      `${anchorlessIds.length} anchorless (skipped)`
     ];
     if (opts.update) summary.push(`${updated} updated on disk`);
     ui.info(summary.join(" \xB7 "));
+    if (anchorlessIds.length > 0) {
+      console.log(
+        ui.dim(
+          `Anchorless memories (no paths/symbols \u2014 staleness cannot be detected):
+` + anchorlessIds.map((id) => `  ${id}`).join("\n") + `
+Tip: use \`haive memory update <id> --paths <files>\` to add anchors.`
+        )
+      );
+    }
   });
 }
 function applyVerification(mem, result) {
@@ -1581,8 +1752,8 @@ function applyVerification(mem, result) {
 }
 
 // src/index.ts
-var program = new Command25();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.2.5");
+var program = new Command26();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.2.7");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
@@ -1608,6 +1779,7 @@ registerMemoryPending(memory);
 registerMemoryApprove(memory);
 registerMemoryUpdate(memory);
 registerMemoryHot(memory);
+registerMemoryTried(memory);
 program.parseAsync(process.argv).catch((err) => {
   if (isZodError(err)) {
     for (const issue of err.issues) {