@hiveai/cli 0.2.4 → 0.2.6

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command24 } 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();
@@ -122,15 +124,34 @@ function parseCsv(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
 
+// src/commands/tui.ts
+import "commander";
+import { findProjectRoot as findProjectRoot2 } from "@hiveai/core";
+function registerTui(program2) {
+  program2.command("tui").description("Interactive TUI dashboard \u2014 browse, filter, and manage memories in the terminal").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    if (!process.stdout.isTTY) {
+      console.error("haive tui requires an interactive terminal (TTY).");
+      process.exitCode = 1;
+      return;
+    }
+    const root = findProjectRoot2(opts.dir);
+    const { render } = await import("ink");
+    const { createElement } = await import("react");
+    const { Dashboard } = await import("./Dashboard-SRPCHP7Z.js");
+    const { waitUntilExit } = render(createElement(Dashboard, { root }));
+    await waitUntilExit();
+  });
+}
+
 // src/commands/embeddings.ts
 import { existsSync as existsSync2 } from "fs";
 import path from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot2, resolveHaivePaths as resolveHaivePaths2 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot3, resolveHaivePaths as resolveHaivePaths2 } from "@hiveai/core";
 function registerEmbeddings(program2) {
   const embeddings = program2.command("embeddings").description("Manage local embeddings index for semantic search");
   embeddings.command("index").description("Generate or refresh the embeddings index for all memories").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot2(opts.dir);
+    const root = findProjectRoot3(opts.dir);
     const paths = resolveHaivePaths2(root);
     if (!existsSync2(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
@@ -147,7 +168,7 @@ function registerEmbeddings(program2) {
     );
   });
   embeddings.command("query <text>").description("Run a semantic search against the local embeddings index").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "10").option("--min-score <n>", "minimum cosine similarity (0-1)", "0").action(async (text, opts) => {
-    const root = findProjectRoot2(opts.dir);
+    const root = findProjectRoot3(opts.dir);
     const paths = resolveHaivePaths2(root);
     const { semanticSearch } = await loadEmbeddings();
     const result = await semanticSearch(paths, text, {
@@ -170,7 +191,7 @@ function registerEmbeddings(program2) {
     }
   });
   embeddings.command("status").description("Show the embeddings index status").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot2(opts.dir);
+    const root = findProjectRoot3(opts.dir);
     const paths = resolveHaivePaths2(root);
     const { indexStat } = await loadEmbeddings();
     const stat = await indexStat(paths);
@@ -201,7 +222,7 @@ import "commander";
 import {
   buildCodeMap,
   codeMapPath,
-  findProjectRoot as findProjectRoot3,
+  findProjectRoot as findProjectRoot4,
   resolveHaivePaths as resolveHaivePaths3,
   saveCodeMap
 } from "@hiveai/core";
@@ -213,7 +234,7 @@ function registerIndexCode(program2) {
     "extra directory names to skip (comma-separated)",
     ""
   ).action(async (opts) => {
-    const root = findProjectRoot3(opts.dir);
+    const root = findProjectRoot4(opts.dir);
     const paths = resolveHaivePaths3(root);
     const extraExcludes = (opts.exclude ?? "").split(",").map((s) => s.trim()).filter(Boolean);
     ui.info(`Indexing source files in ${root}\u2026`);
@@ -311,7 +332,7 @@ import { mkdir as mkdir2, writeFile as writeFile2, chmod, readFile as readFile2
 import { existsSync as existsSync4 } from "fs";
 import path4 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot5 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
 var HOOK_MARKER = "# hAIve auto-generated";
 var HOOK_BODY = `#!/bin/sh
 ${HOOK_MARKER} \u2014 keep this block to allow upgrades. Hand-edit anything outside it.
@@ -327,7 +348,7 @@ fi
 var HOOKS = ["post-merge", "post-rewrite"];
 function registerInstallHooks(program2) {
   program2.command("install-hooks").description("Install git hooks that run `haive sync` after pull/merge").option("-d, --dir <dir>", "project root").option("--force", "overwrite existing hooks").action(async (opts) => {
-    const root = findProjectRoot5(opts.dir);
+    const root = findProjectRoot6(opts.dir);
     const gitDir = path4.join(root, ".git");
     if (!existsSync4(gitDir)) {
       ui.error(`No .git directory at ${root}.`);
@@ -364,11 +385,11 @@ import { createRequire } from "module";
 import path5 from "path";
 import { fileURLToPath } from "url";
 import "commander";
-import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
 var require2 = createRequire(import.meta.url);
 function registerMcp(program2) {
   program2.command("mcp").description("Start the hAIve MCP server (stdio transport)").option("-d, --dir <dir>", "project root (defaults to nearest .ai/ or .git/)").action((opts) => {
-    const root = findProjectRoot6(opts.dir);
+    const root = findProjectRoot7(opts.dir);
     const bin = locateMcpBin();
     if (!bin) {
       ui.error(
@@ -399,13 +420,13 @@ 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,
-  findProjectRoot as findProjectRoot7,
+  findProjectRoot as findProjectRoot8,
   getUsage,
   isAutoPromoteEligible,
   loadMemoriesFromDir as loadMemoriesFromDir2,
@@ -414,12 +435,17 @@ 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) => {
-    const root = findProjectRoot7(opts.dir);
+  ).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)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
@@ -510,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:"));
@@ -526,6 +557,47 @@ 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}`;
+  let existing = existsSync6(bridgeFile) ? await readFile3(bridgeFile, "utf8") : "";
+  const startIdx = existing.indexOf(BRIDGE_START);
+  const endIdx = existing.indexOf(BRIDGE_END);
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
+  } else {
+    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",
@@ -552,15 +624,15 @@ import path7 from "path";
 import "commander";
 import {
   buildFrontmatter,
-  findProjectRoot as findProjectRoot8,
+  findProjectRoot as findProjectRoot9,
   inferModulesFromPaths,
   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) => {
-    const root = findProjectRoot8(opts.dir);
+  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("--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)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
@@ -631,7 +703,7 @@ function parseCsv2(value) {
 import { existsSync as existsSync8 } from "fs";
 import path8 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot9, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
@@ -643,7 +715,7 @@ import {
 // src/commands/memory-list.ts
 function registerMemoryList(memory2) {
   memory2.command("list").description("List memories with optional filters").option("--scope <scope>", "personal | team | module").option("--type <type>", "filter by type").option("--tag <tag>", "filter by tag").option("--module <name>", "filter by module name").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot9(opts.dir);
+    const root = findProjectRoot10(opts.dir);
     const paths = resolveHaivePaths7(root);
     if (!existsSync8(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
@@ -717,14 +789,14 @@ import { existsSync as existsSync9 } from "fs";
 import path9 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot10,
+  findProjectRoot as findProjectRoot11,
   memoryFilePath as memoryFilePath2,
   resolveHaivePaths as resolveHaivePaths8,
   serializeMemory as serializeMemory3
 } from "@hiveai/core";
 function registerMemoryPromote(memory2) {
   memory2.command("promote <id>").description("Promote a personal memory to team scope (status -> proposed)").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot10(opts.dir);
+    const root = findProjectRoot11(opts.dir);
     const paths = resolveHaivePaths8(root);
     if (!existsSync9(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
@@ -776,13 +848,13 @@ import { writeFile as writeFile6 } from "fs/promises";
 import path10 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot11,
+  findProjectRoot as findProjectRoot12,
   resolveHaivePaths as resolveHaivePaths9,
   serializeMemory as serializeMemory4
 } from "@hiveai/core";
 function registerMemoryApprove(memory2) {
   memory2.command("approve [id]").description("Mark a memory as 'validated'. Use --all to bulk-approve all proposed/draft memories.").option("--all", "approve all proposed and draft memories at once").option("--pending", "approve all memories with status 'proposed'").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot11(opts.dir);
+    const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
     if (!existsSync10(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
@@ -847,13 +919,13 @@ import { existsSync as existsSync11 } from "fs";
 import path11 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot12,
+  findProjectRoot as findProjectRoot13,
   resolveHaivePaths as resolveHaivePaths10,
   serializeMemory as serializeMemory5
 } from "@hiveai/core";
 function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot12(opts.dir);
+    const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
     if (!existsSync11(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
@@ -932,7 +1004,7 @@ import path12 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
-  findProjectRoot as findProjectRoot13,
+  findProjectRoot as findProjectRoot14,
   getUsage as getUsage2,
   isAutoPromoteEligible as isAutoPromoteEligible2,
   loadUsageIndex as loadUsageIndex2,
@@ -945,7 +1017,7 @@ function registerMemoryAutoPromote(memory2) {
     "memories with more rejections than this are skipped",
     String(DEFAULT_AUTO_PROMOTE_RULE2.maxRejections)
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot13(opts.dir);
+    const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
     if (!existsSync12(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
@@ -991,17 +1063,17 @@ 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 readFile4 } from "fs/promises";
 import path13 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot14,
+  findProjectRoot as findProjectRoot15,
   parseMemory,
   resolveHaivePaths as resolveHaivePaths12
 } from "@hiveai/core";
 function registerMemoryEdit(memory2) {
   memory2.command("edit <id>").description("Open a memory in $EDITOR and re-validate when you save").option("-e, --editor <cmd>", "editor command (defaults to $EDITOR or 'vi')").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot14(opts.dir);
+    const root = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
     if (!existsSync13(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
@@ -1022,7 +1094,7 @@ function registerMemoryEdit(memory2) {
       ui.warn(`Editor exited with status ${code}.`);
     }
     try {
-      const fresh = await readFile3(found.filePath, "utf8");
+      const fresh = await readFile4(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -1048,7 +1120,7 @@ import path14 from "path";
 import "commander";
 import {
   deriveConfidence,
-  findProjectRoot as findProjectRoot15,
+  findProjectRoot as findProjectRoot16,
   getUsage as getUsage3,
   inferModulesFromPaths as inferModulesFromPaths2,
   loadUsageIndex as loadUsageIndex3,
@@ -1057,7 +1129,7 @@ import {
 } from "@hiveai/core";
 function registerMemoryForFiles(memory2) {
   memory2.command("for-files <files...>").description("Show memories relevant to the given files (anchor overlap, module, domain)").option("-d, --dir <dir>", "project root").action(async (files, opts) => {
-    const root = findProjectRoot15(opts.dir);
+    const root = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
     if (!existsSync14(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
@@ -1121,14 +1193,14 @@ import { existsSync as existsSync15 } from "fs";
 import path15 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot16,
+  findProjectRoot as findProjectRoot17,
   getUsage as getUsage4,
   loadUsageIndex as loadUsageIndex4,
   resolveHaivePaths as resolveHaivePaths14
 } from "@hiveai/core";
 function registerMemoryHot(memory2) {
   memory2.command("hot").description("List memories actively used but not yet validated (good promotion candidates)").option("--threshold <n>", "minimum read_count to qualify", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot16(opts.dir);
+    const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
     if (!existsSync15(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
@@ -1166,21 +1238,78 @@ 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 {
-  findProjectRoot as findProjectRoot17,
+  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 = findProjectRoot17(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;
@@ -1208,29 +1337,30 @@ 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 findProjectRoot18,
+  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 = findProjectRoot18(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;
@@ -1238,25 +1368,35 @@ function registerMemoryQuery(memory2) {
     const tokens = tokenizeQuery2(text);
     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 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}`);
     }
@@ -1268,22 +1408,22 @@ ${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 findProjectRoot19,
+  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 = findProjectRoot19(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;
@@ -1295,9 +1435,9 @@ function registerMemoryReject(memory2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile9(
+    await writeFile10(
       loaded.filePath,
-      serializeMemory7({
+      serializeMemory8({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -1319,22 +1459,22 @@ 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 findProjectRoot20,
+  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 = findProjectRoot20(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;
@@ -1346,7 +1486,7 @@ function registerMemoryRm(memory2) {
       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();
@@ -1370,22 +1510,22 @@ 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 readFile5 } from "fs/promises";
+import path20 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
-  findProjectRoot as findProjectRoot21,
+  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 = findProjectRoot21(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;
@@ -1398,7 +1538,7 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile4(found.filePath, "utf8"));
+      console.log(await readFile5(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
@@ -1414,7 +1554,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}`);
@@ -1429,21 +1569,21 @@ 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 findProjectRoot22,
+  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 = findProjectRoot22(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;
@@ -1468,27 +1608,27 @@ 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 findProjectRoot23,
-  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 = findProjectRoot23(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;
@@ -1511,7 +1651,7 @@ function registerMemoryVerify(memory2) {
         anchorless++;
         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}`);
@@ -1523,7 +1663,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification(mem, result);
-        await writeFile10(filePath, serializeMemory8(next), "utf8");
+        await writeFile11(filePath, serializeMemory9(next), "utf8");
         updated++;
       }
     }
@@ -1562,11 +1702,12 @@ function applyVerification(mem, result) {
 }
 
 // src/index.ts
-var program = new Command24();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.2.4");
+var program = new Command26();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.2.6");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
+registerTui(program);
 registerEmbeddings(program);
 registerSync(program);
 registerInstallHooks(program);
@@ -1588,6 +1729,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) {