@hiveai/cli 0.9.3 → 0.9.6

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command47 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -197,7 +197,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path40, changes]) => ({ path: path40, changes }));
+    let entries = [...counts.entries()].map(([path45, changes]) => ({ path: path45, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -1882,6 +1882,7 @@ var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
 > or invoke the MCP prompt \`bootstrap_project\` in your AI client for a richer AI-generated version.
+> **AI agents**: use the **haive** MCP (\`get_briefing\` / \`mem_relevant_to\`) before substantive edits \u2014 see bridge files and \`.cursor/rules/haive-mcp-required.mdc\`.
 
 ## Architecture
 TODO \u2014 high-level overview of the codebase.
@@ -1906,16 +1907,47 @@ Memories live under \`.ai/memories/\` (personal/team/module).
 
 ## hAIve \u2014 mandatory rules for AI agents
 
+Installing or initializing hAIve in this repository means **the team expects AI agents to drive work through hAIve**, not bypass it.
+
+### MCP first (default \u2014 never optional unless the developer says so)
+The **haive** MCP server must be enabled in your client. Until it is unavailable (misconfiguration report to the developer), you **must** use it for substantive work:
+
+- **Before** you edit project source files, configs (\`package.json\`, tooling), or workflows for the current goal, invoke \`get_briefing\` with a short **task** string (and **files** / **symbols** when you know them). If project context was already refreshed in this session and you only need ranked memories, you may call \`mem_relevant_to\` instead\u2014but **still** consult hAIve before trusting ungrounded guesses.
+- **Before** declaring a coding task finished, invoke the MCP prompt \`post_task\` when the session produced learnings or substantive changes worth capturing.
+
+Do **not** treat these as nice-to-have: they are **default-required** for coding agents here.
+
 ### Session rules
-- **Before** marking a task as done ("Done", "Finished", "C'est fait"), call the MCP prompt \`post_task\`.
 - **Immediately** when an approach fails (wrong API, wrong pattern, wrong assumption), call \`mem_tried\` \u2014 do not wait until the end of the session.
-- When starting a new task, call \`get_briefing\` with the task description to load relevant memories and avoid repeating past mistakes.
 
 ### Safety rules \u2014 NEVER violate these
 - If \`get_briefing\` returns an \`action_required\` list, **stop and show each item to the developer** before doing anything. Use the exact \`developer_message\` provided. Wait for explicit confirmation.
 - **Never modify code autonomously** because of a breaking change detected in another project (dependency version bump, API contract change, removed field). Always ask first.
 - When in doubt about a cross-repo change: ask, don't act.
 `;
+var CURSOR_HAIVE_RULE_MDC = `---
+description: Require hAIve MCP (get_briefing / mem_relevant_to) before substantive repo edits
+alwaysApply: true
+---
+
+# hAIve \u2014 required for agents
+
+This repository uses **hAIve**. Running \`haive init\` means the team expects agents to **use the haive MCP server by default**, not skip it.
+
+## Before you change the repo
+
+1. Call **\`get_briefing\`** with \`task\` (and \`files\` / \`symbols\` when known), **or** \`mem_relevant_to\` if full project context is already loaded and you only need ranked memories.
+2. Then read/search the codebase as needed. Do not invert this order for non-trivial work.
+
+## During / after the task
+
+- On failure: **\`mem_tried\`** immediately.
+- Before closing a substantive session: MCP prompt **\`post_task\`** when there is something worth capturing.
+
+## If haive MCP is missing
+
+Tell the developer to enable the **haive** server (e.g. \`haive mcp --stdio\` in client config) and restart the client. Do not silently ignore hAIve.
+`;
 var CI_WORKFLOW = `name: haive-sync
 
 on:
@@ -2036,7 +2068,7 @@ jobs:
 function registerInit(program2) {
   program2.command("init").description(
     "Initialize a hAIve project \u2014 autopilot mode ON by default (zero human intervention).\n  Auto-bootstraps project-context.md from local files and seeds detected stack packs.\n  Add --manual to control memory approval and session recaps yourself.\n  Add --no-bootstrap and --stack none to disable the auto-features."
-  ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate CLAUDE.md / .cursorrules / copilot-instructions.md").option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
+  ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate CLAUDE.md / .cursorrules / copilot-instructions.md / .cursor/rules/haive-mcp-required.mdc").option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
     "--manual",
     "opt out of autopilot: memories require manual approval, no auto-session recap, no auto-context"
   ).option(
@@ -2066,6 +2098,7 @@ function registerInit(program2) {
     await mkdir3(paths.teamDir, { recursive: true });
     await mkdir3(paths.moduleDir, { recursive: true });
     await mkdir3(paths.modulesContextDir, { recursive: true });
+    await ensureAiRuntimeLayout(paths.runtimeDir);
     if (!existsSync6(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
@@ -2095,6 +2128,7 @@ function registerInit(program2) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
       await writeBridge(root, path7.join(".github", "copilot-instructions.md"));
+      await writeCursorHaiveRule(root);
     }
     const stacksToSeed = await resolveStacksToSeed(root, wantStack);
     if (stacksToSeed.length > 0) {
@@ -2237,6 +2271,17 @@ async function resolveStacksToSeed(root, stackOpt) {
   }
   return stackOpt.split(",").map((s) => s.trim().toLowerCase()).filter(isValidStack);
 }
+async function writeCursorHaiveRule(root) {
+  const relPath = ".cursor/rules/haive-mcp-required.mdc";
+  const target = path7.join(root, relPath);
+  if (existsSync6(target)) {
+    ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
+    return;
+  }
+  await mkdir3(path7.dirname(target), { recursive: true });
+  await writeFile3(target, CURSOR_HAIVE_RULE_MDC, "utf8");
+  ui.success(`Created Cursor rule ${relPath}`);
+}
 async function writeBridge(root, relPath) {
   const target = path7.join(root, relPath);
   if (existsSync6(target)) {
@@ -2247,6 +2292,29 @@ async function writeBridge(root, relPath) {
   await writeFile3(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
+var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
+
+Not team truth. Use for machine-local session notes or tooling scratch files.
+Official memories belong in .ai/memories/ (versioned in Git).
+Only .gitignore and this README are meant to commit; everything else stays untracked.
+
+Session continuity (local): agents may append \`session-journal.ndjson\` via MCP \`runtime_journal_append\` or \`haive runtime journal append\`.
+`;
+var RUNTIME_GITIGNORE_BODY = `*
+!.gitignore
+!README.md
+`;
+async function ensureAiRuntimeLayout(runtimeDir) {
+  await mkdir3(runtimeDir, { recursive: true });
+  const gi = path7.join(runtimeDir, ".gitignore");
+  if (!existsSync6(gi)) {
+    await writeFile3(gi, RUNTIME_GITIGNORE_BODY, "utf8");
+  }
+  const readme = path7.join(runtimeDir, "README.md");
+  if (!existsSync6(readme)) {
+    await writeFile3(readme, RUNTIME_README_BODY, "utf8");
+  }
+}
 async function ensureGitignoreEntries(root, patterns) {
   try {
     const gitignorePath = path7.join(root, ".gitignore");
@@ -2631,6 +2699,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir3,
   loadUsageIndex as loadUsageIndex2,
   pickSnippetNeedle,
+  rankMemoriesLexical,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads2
 } from "@hiveai/core";
@@ -2728,7 +2797,11 @@ import {
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z16 } from "zod";
-import { appendUsageEvent, loadConfig as loadConfig2 } from "@hiveai/core";
+import {
+  appendUsageEvent,
+  appendRuntimeJournalEntry,
+  loadConfig as loadConfig2
+} from "@hiveai/core";
 import { mkdir as mkdir52, writeFile as writeFile9, rm } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
 import path72 from "path";
@@ -2832,9 +2905,27 @@ import {
   serializeMemory as serializeMemory10
 } from "@hiveai/core";
 import { z as z29 } from "zod";
+import { existsSync as existsSync27 } from "fs";
+import {
+  findLexicalConflictPairs,
+  findTopicStatusConflictPairs,
+  loadMemoriesFromDir as loadMemoriesFromDir21
+} from "@hiveai/core";
 import { z as z30 } from "zod";
+import { resolveProjectInfo } from "@hiveai/core";
 import { z as z31 } from "zod";
+import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
 import { z as z32 } from "zod";
+import { existsSync as existsSync28 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir222 } from "@hiveai/core";
+import { z as z33 } from "zod";
+import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
+import { z as z34 } from "zod";
+import { readRuntimeJournalTail } from "@hiveai/core";
+import { z as z35 } from "zod";
+import { z as z36 } from "zod";
+import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
@@ -3119,6 +3210,9 @@ var MemSearchInputSchema = {
   semantic: z5.boolean().default(false).describe(
     "Use semantic similarity from the embeddings index (requires `haive embeddings index`)."
   ),
+  lexical_rank: z5.boolean().default(false).describe(
+    "When true (and semantic is false), rank the filtered corpus with Okapi-BM25-style lexical scoring instead of literal AND/OR. Helps phrase-like queries without embeddings."
+  ),
   min_score: z5.number().min(0).max(1).default(0).describe("Minimum cosine similarity (semantic mode only)"),
   track: z5.boolean().default(true).describe("Increment read_count on returned memories (used for passive validation)")
 };
@@ -3144,6 +3238,27 @@ async function memSearch(input, ctx) {
         notice: "Semantic search unavailable (embeddings index missing or @hiveai/embeddings not installed). Falling back to literal search."
       };
     }
+  } else if (input.lexical_rank && input.query.trim()) {
+    const { ranked, scores } = rankMemoriesLexical(
+      filtered,
+      input.query,
+      input.limit
+    );
+    if (ranked.length > 0) {
+      const snippetNeedle = pickSnippetNeedle(input.query);
+      result = {
+        matches: ranked.map(
+          (loaded, i) => lexicalHit(loaded, snippetNeedle, usage, scores[i])
+        ),
+        total: ranked.length,
+        mode: "lexical_ranked"
+      };
+    } else {
+      result = {
+        ...buildLiteralResult(input, filtered, usage),
+        notice: "Lexical ranking found no BM25-positive hits \u2014 showing literal matches instead."
+      };
+    }
   } else {
     result = buildLiteralResult(input, filtered, usage);
   }
@@ -3241,6 +3356,9 @@ function toHit(loaded, needle, usage) {
     file_path: loaded.filePath
   };
 }
+function lexicalHit(loaded, needle, usage, lexicalScore) {
+  return { ...toHit(loaded, needle, usage), score: lexicalScore };
+}
 var MemVerifyInputSchema = {
   id: z6.string().optional().describe("If set, verify only this memory id"),
   update: z6.boolean().default(false).describe("Write the resulting status back to disk (status=stale or validated)")
@@ -3832,6 +3950,14 @@ var SessionTracker = class {
         recapId = result.id;
       } catch {
       }
+      void appendRuntimeJournalEntry(this.ctx.paths, {
+        kind: "session_end",
+        message: recapId ? `auto session close | ${toolSummary} | recap:${recapId}` : `auto session close | ${toolSummary}`,
+        meta: {
+          recap_id: recapId ?? null,
+          total_tool_calls: totalCalls
+        }
+      });
       const ranPostTask = this.events.some(
         (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
       );
@@ -5572,11 +5698,107 @@ function gitFileDiff(root, file, sinceDays) {
     return null;
   }
 }
+var MemConflictCandidatesInputSchema = {
+  since_days: z30.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z30.array(z30.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z30.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z30.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
+  max_topic_pairs: z30.number().int().positive().max(100).default(20).describe(
+    "Cap for extra signal: memories sharing the same topic with validated vs rejected status."
+  )
+};
+async function memConflictCandidates(input, ctx) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
+    return {
+      pairs: [],
+      topic_status_pairs: [],
+      scanned: 0,
+      truncated: false,
+      notice: "No .ai/memories directory."
+    };
+  }
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
+    sinceDays: input.since_days,
+    types: input.types,
+    minJaccard: input.min_jaccard,
+    maxPairs: input.max_pairs,
+    maxScan: input.max_scan
+  });
+  const topicStatusPairs = findTopicStatusConflictPairs(all, input.max_topic_pairs);
+  const notice = pairs.length === 0 && topicStatusPairs.length === 0 ? "No lexical or topic-status candidates \u2014 widen since_days/types or lower min_jaccard." : void 0;
+  return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
+}
+var MemResolveProjectInputSchema = {
+  cwd: z31.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+};
+async function memResolveProject(input, _ctx) {
+  void _ctx;
+  return {
+    ok: true,
+    info: resolveProjectInfo({
+      cwd: input.cwd
+    })
+  };
+}
+var MemSuggestTopicInputSchema = {
+  type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
+  title: z32.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+};
+async function memSuggestTopic(input, _ctx) {
+  void _ctx;
+  const suggestion = suggestTopicKey(input.type, input.title);
+  return { topic_key: suggestion.topic_key, family: suggestion.family, type: input.type };
+}
+var MemTimelineInputSchema = {
+  memory_id: z33.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z33.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z33.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+};
+async function memTimeline(input, ctx) {
+  if (!existsSync28(ctx.paths.memoriesDir)) {
+    return { entries: [], total: 0, notice: "No .ai/memories directory." };
+  }
+  const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
+  const { entries, notice } = collectTimelineEntries(all, {
+    memoryId: input.memory_id,
+    topic: input.topic,
+    limit: input.limit
+  });
+  return { entries, total: entries.length, notice };
+}
+var RuntimeJournalAppendInputSchema = {
+  message: z34.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z34.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z34.string().optional().describe("When kind=mcp, which tool name (optional)")
+};
+async function runtimeJournalAppend(input, ctx) {
+  await appendRuntimeJournalEntry2(ctx.paths, {
+    kind: input.kind,
+    message: input.message,
+    ...input.tool ? { tool: input.tool } : {}
+  });
+  return {
+    ok: true,
+    path_hint: `${ctx.paths.runtimeDir}/session-journal.ndjson`
+  };
+}
+var RuntimeJournalTailInputSchema = {
+  limit: z35.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+};
+async function runtimeJournalTail(input, ctx) {
+  const entries = await readRuntimeJournalTail(ctx.paths, input.limit);
+  if (entries.length === 0) {
+    return { entries: [], empty: true };
+  }
+  return { entries };
+}
 var BootstrapProjectArgsSchema = {
-  module: z30.string().optional().describe(
+  module: z36.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z30.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z36.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -5657,8 +5879,8 @@ ${template}\`\`\`
   };
 }
 var PostTaskArgsSchema = {
-  task_summary: z31.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z31.array(z31.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z37.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z37.array(z37.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -5741,10 +5963,10 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
   };
 }
 var ImportDocsArgsSchema = {
-  content: z32.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z32.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z32.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z32.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z38.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z38.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z38.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z38.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -5807,7 +6029,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.3";
+var SERVER_VERSION = "0.9.6";
 function jsonResult(data) {
   return {
     content: [
@@ -5858,6 +6080,23 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memSave(input, context));
     }
   );
+  server.tool(
+    "mem_suggest_topic",
+    [
+      "Propose a stable `topic` key (topic-upsert) from type + short title.",
+      "",
+      "USE BEFORE mem_save when you want deterministic updates to the same memory over time;",
+      "families mimic Engram-style grouping (architecture/*, bug/*, decision/*, \u2026).",
+      "",
+      "PARAMETERS:",
+      "  type  \u2014 convention | decision | gotcha | architecture | glossary | attempt | session_recap",
+      "  title \u2014 phrase to slugify under the suggested family prefix",
+      "",
+      "RETURNS: { topic_key, family, type }"
+    ].join("\n"),
+    MemSuggestTopicInputSchema,
+    async (input) => jsonResult(await memSuggestTopic(input, context))
+  );
   server.tool(
     "mem_tried",
     [
@@ -5949,8 +6188,12 @@ function createHaiveServer(options = {}) {
   server.tool(
     "get_briefing",
     [
-      "\u2B50 CALL THIS FIRST at the start of every task. One-shot onboarding that returns",
-      "everything relevant in a single call under a token budget.",
+      "\u2B50 DEFAULT-FIRST for coding agents on any repo where `haive init` ran: call this BEFORE",
+      "changing source or project config for the current goal (unless the developer explicitly opts out).",
+      "One-shot onboarding: everything relevant in a single call under a token budget.",
+      "",
+      "PROGRESSIVE DISCLOSURE \u2014 after this, drill down only if needed:",
+      "  mem_relevant_to / mem_search (compact lists) \u2192 mem_get (full body + anchors).",
       "",
       "RETURNS (in order of priority):",
       "  0. action_required \u2014 \u26A0\uFE0F HANDLE THIS FIRST if non-empty (see protocol below)",
@@ -5985,7 +6228,7 @@ function createHaiveServer(options = {}) {
       "  low           \u2014 proposed, few reads (take with caution)",
       "  unverified    \u2014 draft (unverified: true flag set)",
       "",
-      "Replaces 4\u20135 separate tool calls. Always call this before any other tool."
+      "Replaces 4\u20135 separate tool calls. Prefer this first; use mem_search / mem_get only for follow-up."
     ].join("\n"),
     GetBriefingInputSchema,
     async (input) => {
@@ -6004,6 +6247,8 @@ function createHaiveServer(options = {}) {
       "SEARCH MODES:",
       "  Literal (default): AND search across id, tags, and body \u2014 all tokens must match.",
       "  Falls back to OR automatically if no AND results (partial match).",
+      "  Lexical rank (lexical_rank: true, semantic: false): Okapi-BM25-style scoring on the",
+      "  filtered corpus \u2014 good for phrase-like queries without embeddings.",
       "  Semantic (semantic: true): embedding-based similarity \u2014 finds related memories",
       "  even with different wording. Requires haive embeddings index to be built.",
       "",
@@ -6012,6 +6257,7 @@ function createHaiveServer(options = {}) {
       "  scope    \u2014 filter by personal | team | module",
       "  type     \u2014 filter by convention | decision | gotcha | architecture | glossary",
       "  semantic \u2014 true for embedding-based search (requires @hiveai/embeddings)",
+      "  lexical_rank \u2014 BM25-style ranking (ignored when semantic is true)",
       "  limit    \u2014 max results (default 10)",
       "",
       "RETURNS: array of { id, type, scope, status, confidence, body, match_quality }"
@@ -6022,6 +6268,22 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memSearch(input, context));
     }
   );
+  server.tool(
+    "mem_timeline",
+    [
+      "Chronological view of related memories: by shared frontmatter.topic OR expanded from a seed id",
+      "(related_ids, same topic, overlapping anchor paths \u2014 one extra hop on related_ids).",
+      "",
+      "PARAMETERS:",
+      "  memory_id \u2014 optional seed memory id",
+      "  topic     \u2014 optional topic key (required if memory_id omitted)",
+      "  limit     \u2014 max entries (default 30)",
+      "",
+      "RETURNS: { entries: [{ id, type, scope, created_at, one_line, topic? }], total, notice? }"
+    ].join("\n"),
+    MemTimelineInputSchema,
+    async (input) => jsonResult(await memTimeline(input, context))
+  );
   server.tool(
     "mem_for_files",
     [
@@ -6051,7 +6313,7 @@ function createHaiveServer(options = {}) {
     [
       "Fetch a single memory by its full id with all details.",
       "",
-      "USE WHEN get_briefing returned a memory in 'compact' format and you need",
+      "USE WHEN get_briefing / mem_relevant_to / mem_search returned a compact hit and you need",
       "the full body, or when you know the exact id of a memory.",
       "",
       "PARAMETERS:",
@@ -6139,6 +6401,22 @@ function createHaiveServer(options = {}) {
     CodeMapInputSchema,
     async (input) => jsonResult(await codeMapTool(input, context))
   );
+  server.tool(
+    "mem_resolve_project",
+    [
+      "Diagnostics: resolve which project root hAIve is using (never throws).",
+      "",
+      "USE IN multi-root workspaces or when the agent CWD may not be the repo root \u2014",
+      "mirrors HAIVE_PROJECT_ROOT, findProjectRoot markers, and presence of .ai/memories.",
+      "",
+      "PARAMETERS:",
+      "  cwd \u2014 optional directory used for discovery when HAIVE_PROJECT_ROOT is unset",
+      "",
+      "RETURNS: { ok: true, info: { cwd, resolved_root, haive_project_root_env, \u2026 } }"
+    ].join("\n"),
+    MemResolveProjectInputSchema,
+    async (input) => jsonResult(await memResolveProject(input, context))
+  );
   server.tool(
     "mem_update",
     [
@@ -6272,6 +6550,8 @@ function createHaiveServer(options = {}) {
       "One-shot ranked memories for a task \u2014 use instead of get_briefing when",
       "project context is already loaded and you only want the relevant memory layer.",
       "",
+      "Second step in progressive disclosure (after get_briefing): narrow here, then mem_get for full text.",
+      "",
       "Reuses the same ranking pipeline (anchor / module / literal / semantic) but",
       "skips project_context, modules, action_required, etc.",
       "",
@@ -6429,6 +6709,53 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memConflicts(input, context));
     }
   );
+  server.tool(
+    "mem_conflict_candidates",
+    [
+      "Bulk scan for conflict CANDIDATES (not proof):",
+      "",
+      "  1. Lexical similarity (Jaccard) on decision/architecture-like pairs",
+      "  2. Same frontmatter.topic with validated vs rejected \u2014 quick human-review signal",
+      "",
+      "Advisory only \u2014 follow with mem_conflicts_with on specific ids.",
+      "",
+      "PARAMETERS:",
+      "  since_days, types, min_jaccard, max_pairs, max_scan, max_topic_pairs",
+      "",
+      "RETURNS: { pairs, topic_status_pairs, scanned, truncated, notice? }"
+    ].join("\n"),
+    MemConflictCandidatesInputSchema,
+    async (input) => {
+      tracker.record("mem_conflict_candidates", `${input.since_days}d`);
+      return jsonResult(await memConflictCandidates(input, context));
+    }
+  );
+  server.tool(
+    "runtime_journal_append",
+    [
+      "Append one line to `.ai/.runtime/session-journal.ndjson` \u2014 machine-local session continuity.",
+      "",
+      "Does NOT replace team memories; complements mem_session_end recaps for local traces.",
+      "",
+      "PARAMETERS: message, kind (note|session_end|mcp), optional tool",
+      "",
+      "RETURNS: { ok, path_hint }"
+    ].join("\n"),
+    RuntimeJournalAppendInputSchema,
+    async (input) => jsonResult(await runtimeJournalAppend(input, context))
+  );
+  server.tool(
+    "runtime_journal_tail",
+    [
+      "Read the last N entries from the runtime session journal (parsed JSON lines).",
+      "",
+      "PARAMETERS: limit (default 30, max 500)",
+      "",
+      "RETURNS: { entries: [...], empty?: true }"
+    ].join("\n"),
+    RuntimeJournalTailInputSchema,
+    async (input) => jsonResult(await runtimeJournalTail(input, context))
+  );
   server.tool(
     "pre_commit_check",
     [
@@ -6566,7 +6893,7 @@ function registerMcp(program2) {
 // src/commands/sync.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { readFile as readFile8, writeFile as writeFile13, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import path12 from "path";
 import "commander";
 import {
@@ -6578,7 +6905,7 @@ import {
   isDecaying as isDecaying2,
   loadCodeMap as loadCodeMap4,
   loadConfig as loadConfig4,
-  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadMemoriesFromDir as loadMemoriesFromDir23,
   loadUsageIndex as loadUsageIndex12,
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths7,
@@ -6602,7 +6929,7 @@ function registerSync(program2) {
   ).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").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").action(async (opts) => {
     const root = findProjectRoot10(opts.dir);
     const paths = resolveHaivePaths7(root);
-    if (!existsSync27(paths.memoriesDir)) {
+    if (!existsSync29(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -6618,7 +6945,7 @@ function registerSync(program2) {
     let promoted = 0;
     let autoApproved = 0;
     if (opts.verify !== false) {
-      const memories = await loadMemoriesFromDir21(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
@@ -6679,7 +7006,7 @@ function registerSync(program2) {
       }
     }
     if (opts.promote !== false) {
-      const memories = await loadMemoriesFromDir21(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
       const usage = await loadUsageIndex12(paths);
       const nowMs = Date.now();
       for (const { memory: memory2, filePath } of memories) {
@@ -6718,7 +7045,7 @@ function registerSync(program2) {
       }
     }
     const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
-    const draftMemories = (await loadMemoriesFromDir21(paths.memoriesDir)).filter(
+    const draftMemories = (await loadMemoriesFromDir23(paths.memoriesDir)).filter(
       (m) => m.memory.frontmatter.status === "draft"
     );
     const draftCount = draftMemories.length;
@@ -6753,7 +7080,7 @@ function registerSync(program2) {
       }
     }
     if (!opts.quiet) {
-      const allForDecay = await loadMemoriesFromDir21(paths.memoriesDir);
+      const allForDecay = await loadMemoriesFromDir23(paths.memoriesDir);
       const usageForDecay = await loadUsageIndex12(paths);
       const decaying = allForDecay.filter(({ memory: memory2 }) => {
         const fm = memory2.frontmatter;
@@ -6971,8 +7298,8 @@ Attends une **confirmation explicite** avant d'agir.
   });
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync27(memoriesDir)) return;
-  const all = await loadMemoriesFromDir21(memoriesDir);
+  if (!existsSync29(memoriesDir)) return;
+  const all = await loadMemoriesFromDir23(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
     if (memory2.frontmatter.type === "session_recap") return false;
@@ -6996,7 +7323,7 @@ ${m.memory.body.trim()}`;
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync27(bridgeFile);
+  const fileExists = existsSync29(bridgeFile);
   let existing = fileExists ? await readFile8(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
@@ -7047,14 +7374,14 @@ function collectSinceChanges(root, ref) {
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import path13 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter7,
   findProjectRoot as findProjectRoot11,
   inferModulesFromPaths as inferModulesFromPaths3,
-  loadMemoriesFromDir as loadMemoriesFromDir23,
+  loadMemoriesFromDir as loadMemoriesFromDir24,
   memoryFilePath as memoryFilePath6,
   resolveHaivePaths as resolveHaivePaths8,
   serializeMemory as serializeMemory12
@@ -7086,7 +7413,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case 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 (default: personal, or team in autopilot)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific 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 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot11(opts.dir);
     const paths = resolveHaivePaths8(root);
-    if (!existsSync28(paths.haiveDir)) {
+    if (!existsSync30(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -7097,7 +7424,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync28(path13.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync30(path13.resolve(root, p)));
       if (missing.length > 0) {
         ui.warn(`Anchor path${missing.length > 1 ? "s" : ""} not found in project:`);
         for (const p of missing) ui.warn(`  \u2717 ${p}`);
@@ -7109,7 +7436,7 @@ function registerMemoryAdd(memory2) {
     const title = opts.title ?? opts.slug;
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync28(opts.bodyFile)) {
+      if (!existsSync30(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -7130,9 +7457,9 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? "personal";
-    if (existsSync28(paths.memoriesDir)) {
+    if (existsSync30(paths.memoriesDir)) {
       const incomingHash = createHash2("sha256").update(body.trim()).digest("hex").slice(0, 12);
-      const allForHash = await loadMemoriesFromDir23(paths.memoriesDir);
+      const allForHash = await loadMemoriesFromDir24(paths.memoriesDir);
       const hashDup = allForHash.find(
         ({ memory: memory3 }) => createHash2("sha256").update(memory3.body.trim()).digest("hex").slice(0, 12) === incomingHash && memory3.frontmatter.scope === scope
       );
@@ -7143,8 +7470,8 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync28(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir23(paths.memoriesDir);
+    if (opts.topic && existsSync30(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir24(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
       );
@@ -7182,13 +7509,13 @@ TODO \u2014 write the memory body.
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir9(path13.dirname(file), { recursive: true });
-    if (existsSync28(file)) {
+    if (existsSync30(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync28(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir23(paths.memoriesDir);
+    if (existsSync30(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir24(paths.memoriesDir);
       const slugTokens = opts.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
         const id = memory3.frontmatter.id.toLowerCase();
@@ -7230,14 +7557,14 @@ function parseCsv2(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import path14 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot12, resolveHaivePaths as resolveHaivePaths9 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadMemoriesFromDir as loadMemoriesFromDir25,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -7247,12 +7574,12 @@ 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 = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync29(paths.memoriesDir)) {
+    if (!existsSync31(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(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;
@@ -7315,7 +7642,7 @@ function matchesFilters(loaded, opts) {
 
 // src/commands/memory-promote.ts
 import { mkdir as mkdir10, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import path15 from "path";
 import "commander";
 import {
@@ -7328,12 +7655,12 @@ 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 = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync30(paths.memoriesDir)) {
+    if (!existsSync33(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const teamAndModule = await loadMemoriesFromDir24(paths.memoriesDir);
+    const teamAndModule = await loadMemoriesFromDir25(paths.memoriesDir);
     const alreadyShared = teamAndModule.find(
       (m) => m.memory.frontmatter.id === id && (m.memory.frontmatter.scope === "team" || m.memory.frontmatter.scope === "module")
     );
@@ -7347,7 +7674,7 @@ function registerMemoryPromote(memory2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.personalDir);
+    const all = await loadMemoriesFromDir25(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.)`);
@@ -7373,7 +7700,7 @@ function registerMemoryPromote(memory2) {
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
 import path16 from "path";
 import "commander";
@@ -7386,12 +7713,12 @@ 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 = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync31(paths.memoriesDir)) {
+    if (!existsSync34(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     if (opts.all || opts.pending) {
       const candidates = all.filter((m) => {
         const s = m.memory.frontmatter.status;
@@ -7445,7 +7772,7 @@ function registerMemoryApprove(memory2) {
 
 // src/commands/memory-update.ts
 import { writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import path17 from "path";
 import "commander";
 import {
@@ -7457,12 +7784,12 @@ 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 = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync33(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -7529,7 +7856,7 @@ function parseCsv3(value) {
 
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import path18 from "path";
 import "commander";
 import {
@@ -7549,7 +7876,7 @@ function registerMemoryAutoPromote(memory2) {
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -7558,7 +7885,7 @@ function registerMemoryAutoPromote(memory2) {
       minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE3.minReads),
       maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE3.maxRejections)
     };
-    const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
     const usage = await loadUsageIndex13(paths);
     const eligible = memories.filter(
       ({ memory: memory3 }) => isAutoPromoteEligible3(memory3.frontmatter, getUsage11(usage, memory3.frontmatter.id), rule)
@@ -7592,7 +7919,7 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import { readFile as readFile10 } from "fs/promises";
 import path19 from "path";
 import "commander";
@@ -7605,12 +7932,12 @@ 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 = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync35(paths.memoriesDir)) {
+    if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -7645,7 +7972,7 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import path20 from "path";
 import "commander";
 import {
@@ -7661,12 +7988,12 @@ 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 = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const usage = await loadUsageIndex14(paths);
     const inferred = inferModulesFromPaths4(files);
     const byAnchor = [];
@@ -7773,7 +8100,7 @@ function printGroup(root, label, loaded, usage) {
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import path21 from "path";
 import "commander";
 import {
@@ -7786,13 +8113,13 @@ 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 = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const threshold = Math.max(1, Number(opts.threshold ?? 3));
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const usage = await loadUsageIndex15(paths);
     const candidates = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -7824,7 +8151,7 @@ function registerMemoryHot(memory2) {
 
 // src/commands/memory-tried.ts
 import { mkdir as mkdir11, writeFile as writeFile19 } from "fs/promises";
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import path23 from "path";
 import "commander";
 import {
@@ -7853,7 +8180,7 @@ function registerMemoryTried(memory2) {
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module (default: personal)", "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 = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync38(paths.haiveDir)) {
+    if (!existsSync40(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -7877,7 +8204,7 @@ function registerMemoryTried(memory2) {
     const body = lines.join("\n") + "\n";
     const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir11(path23.dirname(file), { recursive: true });
-    if (existsSync38(file)) {
+    if (existsSync40(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
@@ -7893,7 +8220,7 @@ function parseCsv4(value) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path24 from "path";
 import "commander";
 import {
@@ -7906,12 +8233,12 @@ 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 = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    if (!existsSync41(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const usage = await loadUsageIndex16(paths);
     const proposed = all.filter(({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed") return false;
@@ -7941,7 +8268,7 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import path25 from "path";
 import "commander";
 import {
@@ -7958,7 +8285,7 @@ function registerMemoryQuery(memory2) {
   memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").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 = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync40(paths.memoriesDir)) {
+    if (!existsSync43(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -7969,7 +8296,7 @@ function registerMemoryQuery(memory2) {
       return;
     }
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const passesFilters2 = (mem) => {
       const fm = mem.frontmatter;
       if (opts.scope && fm.scope !== opts.scope) return false;
@@ -8017,7 +8344,7 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot23,
@@ -8031,12 +8358,12 @@ 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 = findProjectRoot23(opts.dir);
     const paths = resolveHaivePaths20(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -8067,7 +8394,7 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import path26 from "path";
 import { createInterface } from "readline/promises";
@@ -8082,12 +8409,12 @@ 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 = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -8118,7 +8445,7 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import { readFile as readFile11 } from "fs/promises";
 import path27 from "path";
 import "commander";
@@ -8133,12 +8460,12 @@ 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 = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -8177,7 +8504,7 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import path28 from "path";
 import "commander";
 import {
@@ -8191,12 +8518,12 @@ 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 = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const usage = await loadUsageIndex20(paths);
     const target = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (target.length === 0) {
@@ -8223,7 +8550,7 @@ function registerMemoryStats(memory2) {
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 import path29 from "path";
 import "commander";
 import {
@@ -8238,12 +8565,12 @@ function registerMemoryVerify(memory2) {
   ).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 back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir24(paths.memoriesDir);
+    const all = await loadMemoriesFromDir25(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}".`);
@@ -8325,7 +8652,7 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile12 } from "fs/promises";
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot28,
@@ -8337,12 +8664,12 @@ function registerMemoryImport(memory2) {
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync47(paths.haiveDir)) {
+    if (!existsSync49(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync47(opts.from)) {
+    if (!existsSync49(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -8375,7 +8702,7 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import { readFile as readFile13, mkdir as mkdir12, writeFile as writeFile23 } from "fs/promises";
 import path30 from "path";
 import "commander";
@@ -8449,7 +8776,7 @@ function registerMemoryImportChangelog(memory2) {
     const root = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
     const changelogPath = path30.resolve(root, opts.fromChangelog);
-    if (!existsSync48(changelogPath)) {
+    if (!existsSync50(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -8535,7 +8862,7 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
 import path31 from "path";
 import "commander";
@@ -8543,7 +8870,7 @@ import {
   deriveConfidence as deriveConfidence12,
   findProjectRoot as findProjectRoot30,
   getUsage as getUsage17,
-  loadMemoriesFromDir as loadMemoriesFromDir25,
+  loadMemoriesFromDir as loadMemoriesFromDir26,
   loadUsageIndex as loadUsageIndex21,
   resolveHaivePaths as resolveHaivePaths27
 } from "@hiveai/core";
@@ -8560,7 +8887,7 @@ function registerMemoryDigest(program2) {
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot30(opts.dir);
     const paths = resolveHaivePaths27(root);
-    if (!existsSync49(paths.memoriesDir)) {
+    if (!existsSync51(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -8568,7 +8895,7 @@ function registerMemoryDigest(program2) {
     const days = Math.max(1, Number(opts.days ?? 7));
     const scopeFilter = opts.scope ?? "team";
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const usage = await loadUsageIndex21(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -8643,20 +8970,20 @@ function registerMemoryDigest(program2) {
 
 // src/commands/session-end.ts
 import { writeFile as writeFile25, mkdir as mkdir13, readFile as readFile14, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import path33 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
   findProjectRoot as findProjectRoot31,
-  loadMemoriesFromDir as loadMemoriesFromDir26,
+  loadMemoriesFromDir as loadMemoriesFromDir27,
   memoryFilePath as memoryFilePath9,
   resolveHaivePaths as resolveHaivePaths28,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path33.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync50(obsFile)) return null;
+  if (!existsSync53(obsFile)) return null;
   const raw = await readFile14(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return null;
   const lines = raw.split("\n").filter(Boolean);
@@ -8737,7 +9064,7 @@ function registerSessionEnd(session2) {
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths28(root);
-    if (!existsSync50(paths.haiveDir)) {
+    if (!existsSync53(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8769,7 +9096,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles);
-    const missingPaths = filesTouched.filter((p) => !existsSync50(path33.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync53(path33.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
@@ -8777,11 +9104,11 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path33.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync50(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync53(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync50(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir26(paths.memoriesDir);
+    if (existsSync53(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir27(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
       );
@@ -8834,7 +9161,7 @@ function parseCsv5(value) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path34 from "path";
 import "commander";
@@ -8869,14 +9196,14 @@ function registerSnapshot(program2) {
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot32(opts.dir);
     const paths = resolveHaivePaths29(root);
-    if (!existsSync51(paths.haiveDir)) {
+    if (!existsSync54(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
       const contractsDir = path34.join(paths.haiveDir, "contracts");
-      if (!existsSync51(contractsDir)) {
+      if (!existsSync54(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -9000,7 +9327,7 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { mkdir as mkdir14, readFile as readFile15, writeFile as writeFile26, copyFile } from "fs/promises";
 import path35 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
@@ -9008,7 +9335,7 @@ import "commander";
 import {
   findProjectRoot as findProjectRoot33,
   loadConfig as loadConfig6,
-  loadMemoriesFromDir as loadMemoriesFromDir27,
+  loadMemoriesFromDir as loadMemoriesFromDir28,
   resolveHaivePaths as resolveHaivePaths30,
   saveConfig as saveConfig2,
   serializeMemory as serializeMemory23
@@ -9102,7 +9429,7 @@ Next steps:
       return;
     }
     const hubRoot = path35.resolve(root, config.hubPath);
-    if (!existsSync53(hubRoot)) {
+    if (!existsSync55(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -9110,7 +9437,7 @@ Next steps:
     const projectName = path35.basename(root);
     const destDir = path35.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir14(destDir, { recursive: true });
-    const all = await loadMemoriesFromDir27(paths.memoriesDir);
+    const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const shared = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && // Don't push imported memories (avoid echo loops)
       !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
@@ -9172,7 +9499,7 @@ Next steps:
     }
     const hubRoot = path35.resolve(root, config.hubPath);
     const hubSharedDir = path35.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync53(hubSharedDir)) {
+    if (!existsSync55(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -9227,7 +9554,7 @@ Next steps:
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
     const sharedDir = path35.join(paths.memoriesDir, "shared");
-    if (existsSync53(sharedDir)) {
+    if (existsSync55(sharedDir)) {
       const { readdir: readdir5 } = await import("fs/promises");
       const sources = (await readdir5(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
@@ -9239,7 +9566,7 @@ Next steps:
     } else {
       console.log(ui.dim("  No imported shared memories yet."));
     }
-    const all = await loadMemoriesFromDir27(paths.memoriesDir);
+    const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const outgoing = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
     );
@@ -9256,13 +9583,13 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import { mkdir as mkdir15, writeFile as writeFile27 } from "fs/promises";
 import path36 from "path";
 import {
   aggregateUsage,
   findProjectRoot as findProjectRoot34,
-  loadMemoriesFromDir as loadMemoriesFromDir28,
+  loadMemoriesFromDir as loadMemoriesFromDir29,
   loadUsageIndex as loadUsageIndex23,
   parseSince,
   readUsageEvents as readUsageEvents2,
@@ -9334,8 +9661,8 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync54(paths.memoriesDir)) {
-    const mems = await loadMemoriesFromDir28(paths.memoriesDir);
+  if (existsSync56(paths.memoriesDir)) {
+    const mems = await loadMemoriesFromDir29(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
       if (fm.type === "session_recap") memoryCount.total_skipped_session++;
@@ -9555,14 +9882,14 @@ function summarize(name, t0, payload, notes) {
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir16, writeFile as writeFile28 } from "fs/promises";
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import path37 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
   findProjectRoot as findProjectRoot36,
-  loadMemoriesFromDir as loadMemoriesFromDir29,
+  loadMemoriesFromDir as loadMemoriesFromDir30,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
@@ -9626,7 +9953,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync55(paths.memoriesDir) ? await loadMemoriesFromDir29(paths.memoriesDir) : [];
+      const existing = existsSync57(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -9650,7 +9977,7 @@ function registerMemorySuggest(memory2) {
         const body = renderTemplate(s);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
         await mkdir16(path37.dirname(file), { recursive: true });
-        if (existsSync55(file)) {
+        if (existsSync57(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path37.relative(root, file)}` });
           continue;
         }
@@ -9748,14 +10075,14 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync58 } from "fs";
 import { writeFile as writeFile29 } from "fs/promises";
 import path38 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot37,
   getUsage as getUsage18,
-  loadMemoriesFromDir as loadMemoriesFromDir30,
+  loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex24,
   resolveHaivePaths as resolveHaivePaths34,
   serializeMemory as serializeMemory25
@@ -9767,7 +10094,7 @@ function registerMemoryArchive(memory2) {
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths34(root);
-    if (!existsSync56(paths.memoriesDir)) {
+    if (!existsSync58(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9779,7 +10106,7 @@ function registerMemoryArchive(memory2) {
       return;
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY2;
-    const all = await loadMemoriesFromDir30(paths.memoriesDir);
+    const all = await loadMemoriesFromDir31(paths.memoriesDir);
     const usage = await loadUsageIndex24(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
@@ -9788,7 +10115,7 @@ function registerMemoryArchive(memory2) {
       if (typeFilter && fm.type !== typeFilter) continue;
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync56(path38.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync58(path38.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -9862,7 +10189,7 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { stat } from "fs/promises";
 import "path";
 import { execSync as execSync3 } from "child_process";
@@ -9873,7 +10200,7 @@ import {
   getUsage as getUsage19,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig7,
-  loadMemoriesFromDir as loadMemoriesFromDir31,
+  loadMemoriesFromDir as loadMemoriesFromDir32,
   loadUsageIndex as loadUsageIndex25,
   readUsageEvents as readUsageEvents4,
   resolveHaivePaths as resolveHaivePaths35
@@ -9886,7 +10213,7 @@ function registerDoctor(program2) {
     const root = findProjectRoot38(opts.dir);
     const paths = resolveHaivePaths35(root);
     const findings = [];
-    if (!existsSync57(paths.haiveDir)) {
+    if (!existsSync59(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -9895,7 +10222,7 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync57(paths.projectContext)) {
+    if (!existsSync59(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -9915,7 +10242,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync57(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
+    const memories = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -10039,7 +10366,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.3";
+      const cliVersion = "0.9.6";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10088,11 +10415,11 @@ function isSearchTool(name) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot39,
-  loadMemoriesFromDir as loadMemoriesFromDir32,
+  loadMemoriesFromDir as loadMemoriesFromDir33,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
   resolveHaivePaths as resolveHaivePaths36
@@ -10118,7 +10445,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
+    const all = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
     const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
     const enriched = sessions.map((s, i) => {
       const startMs = Date.parse(s.start);
@@ -10312,11 +10639,11 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot41,
-  loadMemoriesFromDir as loadMemoriesFromDir33,
+  loadMemoriesFromDir as loadMemoriesFromDir34,
   resolveHaivePaths as resolveHaivePaths38
 } from "@hiveai/core";
 var TYPE_RANK = {
@@ -10333,12 +10660,12 @@ function registerWelcome(program2) {
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot41(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync59(paths.memoriesDir)) {
+    if (!existsSync61(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir33(paths.memoriesDir);
+    const all = await loadMemoriesFromDir34(paths.memoriesDir);
     const team = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "team" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && memory2.frontmatter.status !== "stale" && memory2.frontmatter.type !== "session_recap"
     );
@@ -10374,18 +10701,18 @@ function registerWelcome(program2) {
 }
 
 // src/commands/memory-lint.ts
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot42,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
   resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 async function lintMemoriesAsync(root) {
   const paths = resolveHaivePaths39(root);
   const out = [];
-  if (!existsSync60(paths.memoriesDir)) return out;
-  const loaded = await loadMemoriesFromDir34(paths.memoriesDir);
+  if (!existsSync63(paths.memoriesDir)) return out;
+  const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
   const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
   for (const { filePath, memory: memory2 } of loaded) {
     const fm = memory2.frontmatter;
@@ -10472,11 +10799,182 @@ function registerMemoryLint(parent) {
   });
 }
 
+// src/commands/memory-suggest-topic.ts
+import "commander";
+import { MemoryTypeSchema as MemoryTypeSchema2, suggestTopicKey as suggestTopicKey2 } from "@hiveai/core";
+function registerMemorySuggestTopic(memory2) {
+  memory2.command("suggest-topic").description("Suggest a stable topic key (topic-upsert) from type + title phrase").requiredOption(
+    "--type <type>",
+    "convention | decision | gotcha | architecture | glossary | attempt | session_recap"
+  ).argument("<title>", "Short title or phrase to slugify").action((title, opts) => {
+    const parsed = MemoryTypeSchema2.safeParse(opts.type);
+    if (!parsed.success) {
+      ui.error(`Invalid type: ${opts.type}`);
+      process.exit(1);
+    }
+    const suggestion = suggestTopicKey2(parsed.data, title);
+    console.log(JSON.stringify({ type: parsed.data, ...suggestion }, null, 2));
+  });
+}
+
+// src/commands/resolve-project.ts
+import path40 from "path";
+import "commander";
+import { resolveProjectInfo as resolveProjectInfo2 } from "@hiveai/core";
+function registerResolveProject(program2) {
+  program2.command("resolve-project").description(
+    "Print JSON for hAIve project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
+  ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
+    const info = resolveProjectInfo2({ cwd: path40.resolve(opts.dir) });
+    console.log(JSON.stringify({ ok: true, info }, null, 2));
+  });
+}
+
+// src/commands/runtime-journal.ts
+import { existsSync as existsSync64 } from "fs";
+import path41 from "path";
+import "commander";
+import {
+  appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
+  findProjectRoot as findProjectRoot43,
+  readRuntimeJournalTail as readRuntimeJournalTail2,
+  resolveHaivePaths as resolveHaivePaths40
+} from "@hiveai/core";
+function registerRuntime(program2) {
+  const runtime = program2.command("runtime").description(
+    "Local-only .ai/.runtime helpers (not versioned team memory). See session-journal.ndjson."
+  );
+  const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
+  journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
+    const root = path41.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const raw = opts.kind ?? "note";
+    const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
+    await appendRuntimeJournalEntry3(paths, { kind, message });
+    ui.success(`Appended to ${path41.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+  });
+  journal.command("tail").description("Print the last N entries from the runtime session journal as JSON").option("-n, --limit <n>", "number of lines", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
+    const root = path41.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
+    if (!existsSync64(paths.haiveDir)) {
+      ui.error("No .ai/ \u2014 run `haive init` first.");
+      process.exitCode = 1;
+      return;
+    }
+    const entries = await readRuntimeJournalTail2(paths, limit);
+    if (entries.length === 0) {
+      ui.info("Journal empty or missing.");
+      return;
+    }
+    console.log(JSON.stringify({ entries, count: entries.length }, null, 2));
+  });
+}
+
+// src/commands/memory-timeline.ts
+import { existsSync as existsSync65 } from "fs";
+import path43 from "path";
+import "commander";
+import {
+  collectTimelineEntries as collectTimelineEntries2,
+  findProjectRoot as findProjectRoot44,
+  resolveHaivePaths as resolveHaivePaths41
+} from "@hiveai/core";
+function registerMemoryTimeline(memory2) {
+  memory2.command("timeline").description(
+    "List related memories chronologically (topic, related_ids, anchors) \u2014 same logic as MCP mem_timeline."
+  ).option("--id <id>", "seed memory id").option("--topic <key>", "filter by frontmatter.topic (use without --id for topic-only)").option("-n, --limit <n>", "max entries", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
+    if (!opts.id && !opts.topic) {
+      ui.error("Provide --id and/or --topic.");
+      process.exitCode = 1;
+      return;
+    }
+    const root = path43.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths41(findProjectRoot44(root));
+    if (!existsSync65(paths.memoriesDir)) {
+      ui.error("No memories \u2014 run `haive init`.");
+      process.exitCode = 1;
+      return;
+    }
+    const limit = Math.min(100, Math.max(1, parseInt(opts.limit, 10) || 30));
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const { entries, notice } = collectTimelineEntries2(all, {
+      memoryId: opts.id,
+      topic: opts.topic,
+      limit
+    });
+    if (notice) ui.warn(notice);
+    console.log(JSON.stringify({ entries, total: entries.length }, null, 2));
+  });
+}
+
+// src/commands/memory-conflict-candidates.ts
+import { existsSync as existsSync66 } from "fs";
+import path44 from "path";
+import "commander";
+import {
+  findLexicalConflictPairs as findLexicalConflictPairs2,
+  findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
+  findProjectRoot as findProjectRoot45,
+  resolveHaivePaths as resolveHaivePaths42
+} from "@hiveai/core";
+function parseTypes(csv) {
+  const allowed = ["decision", "architecture", "convention", "gotcha"];
+  const parts = csv.split(",").map((s) => s.trim().toLowerCase());
+  const out = parts.filter((p) => allowed.includes(p));
+  return out.length ? out : ["decision", "architecture"];
+}
+function registerMemoryConflictCandidates(memory2) {
+  memory2.command("conflict-candidates").description(
+    "Heuristic conflict candidates (lexical Jaccard + same-topic validated/rejected pairs) \u2014 aligns with MCP mem_conflict_candidates."
+  ).option("-d, --dir <dir>", "project root", process.cwd()).option("--since-days <n>", "only memories created within N days (lexical scan)", "365").option(
+    "--types <csv>",
+    "decision,architecture,convention,gotcha (lexical scan)",
+    "decision,architecture"
+  ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
+    const root = path44.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot45(root));
+    if (!existsSync66(paths.memoriesDir)) {
+      ui.error("No memories \u2014 run `haive init`.");
+      process.exitCode = 1;
+      return;
+    }
+    const sinceDays = Math.max(1, parseInt(opts.sinceDays, 10) || 365);
+    const minJaccard = parseFloat(opts.minJaccard) || 0.45;
+    const maxPairs = Math.min(100, Math.max(1, parseInt(opts.maxPairs, 10) || 20));
+    const maxScan = Math.min(2e3, Math.max(1, parseInt(opts.maxScan, 10) || 500));
+    const maxTopicPairs = Math.min(100, Math.max(1, parseInt(opts.maxTopicPairs, 10) || 20));
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const lexical = findLexicalConflictPairs2(all, {
+      sinceDays,
+      types: parseTypes(opts.types),
+      minJaccard,
+      maxPairs,
+      maxScan
+    });
+    const topicStatusPairs = findTopicStatusConflictPairs2(all, maxTopicPairs);
+    console.log(
+      JSON.stringify(
+        {
+          pairs: lexical.pairs,
+          topic_status_pairs: topicStatusPairs,
+          scanned: lexical.scanned,
+          truncated: lexical.truncated
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+
 // src/index.ts
-var program = new Command42();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.3");
+var program = new Command47();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.6");
 registerInit(program);
 registerWelcome(program);
+registerResolveProject(program);
+registerRuntime(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);
@@ -10507,6 +11005,9 @@ registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);
 registerMemorySuggest(memory);
+registerMemorySuggestTopic(memory);
+registerMemoryTimeline(memory);
+registerMemoryConflictCandidates(memory);
 registerMemoryArchive(memory);
 registerMemoryLint(memory);
 var session = program.command("session").description("Manage session lifecycle");