@hiveai/cli 0.12.4 → 0.13.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command56 } from "commander";
+import { Command as Command58 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -199,7 +199,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path54, changes]) => ({ path: path54, changes }));
+    let entries = [...counts.entries()].map(([path55, changes]) => ({ path: path55, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -2183,7 +2183,11 @@ causes a cryptic runtime error. Check for browser globals (window, document, loc
       body: `Only environment variables prefixed with NEXT_PUBLIC_ are exposed to the browser.
 
 Never put secrets in NEXT_PUBLIC_* variables \u2014 they are bundled into the client JS.
-Variables without the prefix are server-only and safe for API keys, database URLs, etc.`
+Variables without the prefix are server-only and safe for API keys, database URLs, etc.`,
+      sensor: {
+        pattern: "NEXT_PUBLIC_[A-Z0-9_]*(SECRET|PRIVATE|TOKEN|PASSWORD|API_?KEY)",
+        message: "A NEXT_PUBLIC_ env var with a secret-looking name is bundled into client JS \u2014 move the secret to a server-only (non-NEXT_PUBLIC_) variable."
+      }
     },
     {
       slug: "nextjs-fetch-cache-defaults",
@@ -2251,7 +2255,11 @@ and event listeners that accumulate across re-renders.`
 
 Using index as key causes React to re-render wrong items on reorder/filter,
 corrupts form state, and triggers avoidable DOM mutations.
-Use item.id or a stable hash \u2014 never Math.random().`
+Use item.id or a stable hash \u2014 never Math.random().`,
+      sensor: {
+        pattern: "key=\\{\\s*index\\s*\\}",
+        message: "Array index used as a React key \u2014 switch to a stable unique id to avoid state corruption on reorder."
+      }
     },
     {
       slug: "react-avoid-use-effect-for-derived-state",
@@ -2682,6 +2690,256 @@ new ApolloServer({
 });
 \`\`\``
     }
+  ],
+  fastapi: [
+    {
+      slug: "fastapi-validate-with-pydantic",
+      type: "convention",
+      tags: ["fastapi", "python", "validation"],
+      body: `Declare request/response models with Pydantic \u2014 never read raw dict bodies.
+
+\`\`\`py
+class CreateUser(BaseModel):
+    email: EmailStr
+    age: int = Field(ge=0)
+
+@app.post("/users")
+def create(user: CreateUser): ...
+\`\`\`
+
+Pydantic validates and coerces at the boundary; raw \`dict\` bodies bypass validation and typing.`
+    },
+    {
+      slug: "fastapi-no-blocking-io-in-async",
+      type: "gotcha",
+      tags: ["fastapi", "python", "async", "performance"],
+      body: `Never call blocking I/O (requests, time.sleep, sync DB drivers) inside an \`async def\` route.
+
+A blocking call inside the event loop freezes the whole worker for every concurrent request.
+Use an async client (httpx.AsyncClient, asyncpg) or run blocking work in a threadpool
+(\`await run_in_threadpool(...)\` / \`def\` route, which FastAPI runs in a threadpool).`
+    },
+    {
+      slug: "fastapi-uvicorn-reload-not-in-prod",
+      type: "gotcha",
+      tags: ["fastapi", "python", "deployment"],
+      body: `\`uvicorn.run(..., reload=True)\` is a dev-only feature \u2014 never ship it to production.
+
+Reload spawns a file-watcher process and disables multi-worker scaling.
+In production run \`uvicorn app:app --workers N\` (no reload) behind a process manager.`,
+      sensor: {
+        pattern: "uvicorn\\.run\\([^)]*reload\\s*=\\s*True",
+        message: "uvicorn reload=True is dev-only \u2014 remove it from production entrypoints."
+      }
+    },
+    {
+      slug: "fastapi-no-bare-except",
+      type: "convention",
+      tags: ["fastapi", "python", "error-handling"],
+      body: `Never use a bare \`except:\` \u2014 it swallows KeyboardInterrupt/SystemExit and hides real bugs.
+
+Catch the specific exception you expect, or \`except Exception as e:\` at most, and log it.`,
+      sensor: {
+        pattern: "except\\s*:",
+        message: "Bare `except:` swallows everything (incl. KeyboardInterrupt) \u2014 catch a specific exception type."
+      }
+    }
+  ],
+  django: [
+    {
+      slug: "django-debug-false-in-prod",
+      type: "gotcha",
+      tags: ["django", "python", "security", "deployment"],
+      body: `\`DEBUG = True\` in production leaks stack traces, settings, and SQL to any visitor.
+
+Drive it from the environment and default to safe:
+
+\`\`\`py
+DEBUG = os.environ.get("DJANGO_DEBUG", "0") == "1"
+\`\`\``,
+      sensor: {
+        pattern: "DEBUG\\s*=\\s*True",
+        message: "DEBUG = True leaks internals in production \u2014 read it from the environment and default to False."
+      }
+    },
+    {
+      slug: "django-secret-key-from-env",
+      type: "gotcha",
+      tags: ["django", "python", "security"],
+      body: `Never hardcode SECRET_KEY in settings \u2014 load it from the environment.
+
+A committed SECRET_KEY lets anyone forge sessions and signed tokens.
+
+\`\`\`py
+SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
+\`\`\``,
+      sensor: {
+        pattern: `SECRET_KEY\\s*=\\s*["'][^"']+["']`,
+        message: "Hardcoded SECRET_KEY \u2014 load it from os.environ instead of committing a literal."
+      }
+    },
+    {
+      slug: "django-select-related-n-plus-one",
+      type: "gotcha",
+      tags: ["django", "python", "orm", "performance"],
+      body: `Accessing a ForeignKey in a loop triggers one query per row (N+1).
+
+Use \`select_related\` (FK / one-to-one, SQL JOIN) and \`prefetch_related\` (M2M / reverse FK):
+
+\`\`\`py
+for order in Order.objects.select_related("customer").all():
+    order.customer.name  # no extra query
+\`\`\``
+    }
+  ],
+  flask: [
+    {
+      slug: "flask-no-debug-in-prod",
+      type: "gotcha",
+      tags: ["flask", "python", "security", "deployment"],
+      body: `\`app.run(debug=True)\` enables the Werkzeug debugger \u2014 remote code execution if exposed.
+
+Never ship debug mode. Run behind a real WSGI server (gunicorn/uwsgi) in production and
+drive debug from the environment for local dev only.`,
+      sensor: {
+        pattern: "app\\.run\\([^)]*debug\\s*=\\s*True",
+        message: "Flask debug=True exposes the Werkzeug console (RCE) \u2014 never run it in production."
+      }
+    },
+    {
+      slug: "flask-secret-key-from-env",
+      type: "convention",
+      tags: ["flask", "python", "security"],
+      body: `Load \`SECRET_KEY\` from the environment \u2014 never commit a literal.
+
+\`\`\`py
+app.config["SECRET_KEY"] = os.environ["SECRET_KEY"]
+\`\`\`
+A committed key lets anyone forge sessions and CSRF tokens.`
+    },
+    {
+      slug: "flask-no-sql-string-interpolation",
+      type: "gotcha",
+      tags: ["flask", "python", "security", "sql-injection"],
+      body: `Never build SQL with f-strings/%-formatting \u2014 use parameterized queries.
+
+\`\`\`py
+# \u274C SQL injection
+db.execute(f"SELECT * FROM users WHERE id = {uid}")
+# \u2705
+db.execute("SELECT * FROM users WHERE id = %s", (uid,))
+\`\`\``
+    }
+  ],
+  vue: [
+    {
+      slug: "vue-v-html-xss",
+      type: "gotcha",
+      tags: ["vue", "security", "xss"],
+      body: `\`v-html\` renders raw HTML and bypasses Vue's escaping \u2014 an XSS sink for user content.
+
+Only use it on trusted/sanitized content. Prefer text interpolation ({{ }}) or sanitize
+with DOMPurify before binding.`,
+      sensor: {
+        pattern: "v-html",
+        message: "v-html renders unescaped HTML (XSS risk) \u2014 sanitize the value or use text interpolation."
+      }
+    },
+    {
+      slug: "vue-key-in-v-for",
+      type: "convention",
+      tags: ["vue", "performance"],
+      body: `Always bind a stable \`:key\` on \`v-for\` \u2014 and never the loop index.
+
+Index keys corrupt component state on reorder/insert, exactly like React. Use a stable id.`
+    },
+    {
+      slug: "vue-props-are-readonly",
+      type: "gotcha",
+      tags: ["vue", "reactivity"],
+      body: `Never mutate a prop inside a child component \u2014 props are one-way (parent \u2192 child).
+
+Mutating a prop breaks the data flow and warns in dev. Emit an event (\`update:modelValue\`)
+or copy the prop into local state, depending on intent.`
+    }
+  ],
+  spring: [
+    {
+      slug: "spring-constructor-injection",
+      type: "convention",
+      tags: ["spring", "java", "di", "testing"],
+      body: `Prefer constructor injection over \`@Autowired\` field injection.
+
+Constructor injection makes dependencies explicit, allows \`final\` fields, and lets you
+instantiate the class in tests without a Spring context. Field injection hides dependencies
+and forces reflection-based test setup.`
+    },
+    {
+      slug: "spring-no-cors-wildcard",
+      type: "gotcha",
+      tags: ["spring", "java", "security", "cors"],
+      body: `\`@CrossOrigin(origins = "*")\` (or wildcard CORS config) allows any site to call your API.
+
+Combined with credentials it leaks authenticated data cross-origin. Whitelist explicit origins.`,
+      sensor: {
+        pattern: "@CrossOrigin\\([^)]*\\*",
+        message: 'Wildcard CORS (@CrossOrigin origins="*") lets any site call your API \u2014 whitelist explicit origins.'
+      }
+    },
+    {
+      slug: "spring-no-field-secrets",
+      type: "convention",
+      tags: ["spring", "java", "security", "config"],
+      body: `Keep secrets in externalized config (env / vault / application.yml placeholders), not in source.
+
+\`\`\`java
+@Value("\${app.api-key}") private String apiKey; // resolved from env, not hardcoded
+\`\`\``
+    }
+  ],
+  go: [
+    {
+      slug: "go-check-every-error",
+      type: "convention",
+      tags: ["go", "error-handling"],
+      body: `Check every returned error \u2014 never discard it with \`_\`.
+
+\`\`\`go
+// \u274C silently ignores failure
+val, _ := doThing()
+
+// \u2705
+val, err := doThing()
+if err != nil {
+    return fmt.Errorf("doThing: %w", err)
+}
+\`\`\`
+Wrap with \`%w\` to preserve the chain for errors.Is/As.`
+    },
+    {
+      slug: "go-defer-close-after-error-check",
+      type: "gotcha",
+      tags: ["go", "resources"],
+      body: `Place \`defer rows.Close()\` (or file/body Close) AFTER checking the open error, not before.
+
+\`\`\`go
+rows, err := db.Query(q)
+if err != nil { return err }
+defer rows.Close() // only reached when rows is non-nil
+\`\`\`
+Deferring before the error check can call Close on a nil resource and panic.`
+    },
+    {
+      slug: "go-context-first-param",
+      type: "convention",
+      tags: ["go", "context", "api-design"],
+      body: `context.Context is always the FIRST parameter and is never stored in a struct.
+
+\`\`\`go
+func Fetch(ctx context.Context, id string) (*User, error)
+\`\`\`
+Pass it explicitly down the call chain so cancellation and deadlines propagate.`
+    }
   ]
 };
 var SEED_FOOTER = (stack) => `> _Seeded by \`haive init\` from the **${stack}** stack pack \u2014 generic guidance, not repo-specific. Anchor it to a real file or replace it with a repo-specific note to raise it above background priority._`;
@@ -2721,6 +2979,16 @@ async function seedStackPack(haivePaths, stack) {
   await mkdir4(haivePaths.teamDir, { recursive: true });
   let count = 0;
   for (const mem of memories) {
+    const sensor = mem.sensor ? {
+      kind: "regex",
+      pattern: mem.sensor.pattern,
+      ...mem.sensor.flags ? { flags: mem.sensor.flags } : {},
+      paths: mem.sensor.paths ?? [],
+      message: mem.sensor.message,
+      severity: "warn",
+      autogen: false,
+      last_fired: null
+    } : void 0;
     const fm = buildFrontmatter({
       type: mem.type,
       slug: `${stack}-${mem.slug}`,
@@ -2728,7 +2996,8 @@ async function seedStackPack(haivePaths, stack) {
       status: "validated",
       // STACK_PACK_TAG marks this as generic seed knowledge so briefing ranking
       // keeps it at `background` priority until it earns a repo-specific anchor.
-      tags: [...mem.tags, STACK_PACK_TAG]
+      tags: [...mem.tags, STACK_PACK_TAG],
+      ...sensor ? { sensor } : {}
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
     if (existsSync9(filePath)) continue;
@@ -2743,7 +3012,7 @@ ${SEED_FOOTER(stack)}` });
 }
 
 // src/commands/init.ts
-var HAIVE_GITHUB_ACTION_REF = `v${"0.12.4"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.13.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -2931,7 +3200,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 / .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(
+  ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate CLAUDE.md / AGENTS.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(
@@ -2994,6 +3263,7 @@ function registerInit(program2) {
     }
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
+      await writeBridge(root, "AGENTS.md");
       await writeBridge(root, ".cursorrules");
       await writeBridge(root, path10.join(".github", "copilot-instructions.md"));
       await writeCursorHaiveRule(root);
@@ -3731,37 +4001,49 @@ import {
   suggestSensorFromMemory as suggestSensorFromMemory2
 } from "@hiveai/core";
 import { z as z15 } from "zod";
-import { mkdir as mkdir42, writeFile as writeFile82 } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
+import { mkdir as mkdir42, readFile as readFile32, writeFile as writeFile82 } from "fs/promises";
 import path62 from "path";
 import {
-  buildFrontmatter as buildFrontmatter3,
-  isLikelyGuessable,
+  draftsFromFindings,
+  filterNewDrafts,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   memoryFilePath as memoryFilePath3,
+  parseFindings,
   serializeMemory as serializeMemory7
 } from "@hiveai/core";
 import { z as z16 } from "zod";
-import { writeFile as writeFile10, mkdir as mkdir62 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path82 from "path";
+import { mkdir as mkdir52, writeFile as writeFile92 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path72 from "path";
 import {
-  buildFrontmatter as buildFrontmatter4,
-  loadMemoriesFromDir as loadMemoriesFromDir13,
+  buildFrontmatter as buildFrontmatter3,
+  isLikelyGuessable,
   memoryFilePath as memoryFilePath4,
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z17 } from "zod";
+import { writeFile as writeFile11, mkdir as mkdir72 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path92 from "path";
+import {
+  buildFrontmatter as buildFrontmatter4,
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  memoryFilePath as memoryFilePath5,
+  serializeMemory as serializeMemory9
+} from "@hiveai/core";
+import { z as z18 } from "zod";
 import {
   appendUsageEvent,
   appendRuntimeJournalEntry,
   loadConfig as loadConfig22
 } from "@hiveai/core";
-import { mkdir as mkdir52, writeFile as writeFile92, rm } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import path72 from "path";
+import { mkdir as mkdir62, writeFile as writeFile10, rm } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path82 from "path";
 import { execSync } from "child_process";
-import { readFile as readFile42, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile52, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
 import {
   allocateBudget,
   computeImpact as computeImpact2,
@@ -3779,13 +4061,13 @@ import {
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig3,
-  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths22,
   rankMemoriesLexical as rankMemoriesLexical2,
   queryCodeMap as queryCodeMap2,
   resolveBriefingBudget as resolveBriefingBudget2,
-  serializeMemory as serializeMemory9,
+  serializeMemory as serializeMemory10,
   specificityScore as specificityScore2,
   GUESSABLE_THRESHOLD,
   tokenizeQuery as tokenizeQuery22,
@@ -3793,34 +4075,34 @@ import {
   truncateToTokens,
   writeBriefingMarker as writeBriefingMarker2
 } from "@hiveai/core";
-import { z as z18 } from "zod";
-import { readdir as readdir3, readFile as readFile32 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import path92 from "path";
+import { z as z19 } from "zod";
+import { readdir as readdir3, readFile as readFile42 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import path102 from "path";
 import { isGlobPath, isStackPackSeed as isStackPackSeed2, pathsOverlap } from "@hiveai/core";
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap22, queryCodeMap as queryCodeMap22 } from "@hiveai/core";
-import { z as z19 } from "zod";
-import { existsSync as existsSync21 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
 import { z as z20 } from "zod";
 import { existsSync as existsSync222 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir16 } from "@hiveai/core";
 import { z as z21 } from "zod";
+import { existsSync as existsSync23 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir17 } from "@hiveai/core";
 import { z as z22 } from "zod";
 import { z as z23 } from "zod";
-import { existsSync as existsSync23 } from "fs";
+import { z as z24 } from "zod";
+import { existsSync as existsSync24 } from "fs";
 import { spawn } from "child_process";
-import path102 from "path";
+import path112 from "path";
 import {
   deriveConfidence as deriveConfidence5,
   getUsage as getUsage7,
   loadCodeMap as loadCodeMap32,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadMemoriesFromDir as loadMemoriesFromDir18,
   loadUsageIndex as loadUsageIndex9,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
 } from "@hiveai/core";
-import { z as z24 } from "zod";
-import { existsSync as existsSync24 } from "fs";
+import { z as z25 } from "zod";
+import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
   buildDocFrequency,
@@ -3829,7 +4111,7 @@ import {
   diffHasDistinctiveOverlap,
   getUsage as getUsage8,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadMemoriesFromDir as loadMemoriesFromDir19,
   loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
@@ -3837,66 +4119,66 @@ import {
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
-import { z as z25 } from "zod";
-import { existsSync as existsSync25 } from "fs";
+import { z as z26 } from "zod";
+import { existsSync as existsSync26 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir19,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
   tokenizeQuery as tokenizeQuery4
 } from "@hiveai/core";
-import { z as z26 } from "zod";
-import { existsSync as existsSync26 } from "fs";
+import { z as z27 } from "zod";
+import { existsSync as existsSync27 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import {
   deriveConfidence as deriveConfidence7,
   getUsage as getUsage9,
-  loadMemoriesFromDir as loadMemoriesFromDir20,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
   loadUsageIndex as loadUsageIndex11,
   pathsOverlap as singlePathsOverlap
 } from "@hiveai/core";
-import { z as z27 } from "zod";
-import { existsSync as existsSync27 } from "fs";
+import { z as z28 } from "zod";
+import { existsSync as existsSync28 } from "fs";
 import {
   deriveConfidence as deriveConfidence8,
   getUsage as getUsage10,
-  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadMemoriesFromDir as loadMemoriesFromDir222,
   loadUsageIndex as loadUsageIndex12,
   pathsOverlap as pathsOverlap2,
   tokenizeQuery as tokenizeQuery5
 } from "@hiveai/core";
-import { z as z28 } from "zod";
 import { z as z29 } from "zod";
-import { mkdir as mkdir72, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path112 from "path";
+import { z as z30 } from "zod";
+import { mkdir as mkdir82, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
+import path122 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
   buildFrontmatter as buildFrontmatter5,
-  memoryFilePath as memoryFilePath5,
+  memoryFilePath as memoryFilePath6,
   readUsageEvents,
-  serializeMemory as serializeMemory10
+  serializeMemory as serializeMemory11
 } from "@hiveai/core";
-import { z as z30 } from "zod";
-import { existsSync as existsSync29 } from "fs";
+import { z as z31 } from "zod";
+import { existsSync as existsSync30 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir222
+  loadMemoriesFromDir as loadMemoriesFromDir23
 } from "@hiveai/core";
-import { z as z31 } from "zod";
-import { resolveProjectInfo } from "@hiveai/core";
 import { z as z32 } from "zod";
-import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
+import { resolveProjectInfo } from "@hiveai/core";
 import { z as z33 } from "zod";
-import { existsSync as existsSync30 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir23 } from "@hiveai/core";
+import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
 import { z as z34 } from "zod";
-import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
+import { existsSync as existsSync31 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir24 } from "@hiveai/core";
 import { z as z35 } from "zod";
-import { readRuntimeJournalTail } from "@hiveai/core";
+import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
 import { z as z36 } from "zod";
+import { readRuntimeJournalTail } from "@hiveai/core";
 import { z as z37 } from "zod";
 import { z as z38 } from "zod";
 import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 import { hasRecentBriefingMarker, loadConfigSync } from "@hiveai/core";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
@@ -4879,21 +5161,98 @@ async function memTried(input, ctx) {
   await writeFile72(file, serializeMemory6({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
-var MemObserveInputSchema = {
-  what: z16.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
-  where: z16.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
-  impact: z16.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
-  fix: z16.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
-  scope: z16.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+var IngestFindingsInputSchema = {
+  format: z16.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
+  report_path: z16.string().optional().describe("Project-relative path to the findings JSON file. Provide this OR `report`."),
+  report: z16.string().optional().describe("Inline findings JSON content. Provide this OR `report_path`."),
+  type: z16.enum(["gotcha", "convention"]).default("gotcha").describe("Memory type for the created drafts"),
+  scope: z16.enum(["personal", "team", "module"]).default("team").describe("Visibility scope for the created memories"),
   module: z16.string().optional().describe("Module name (required when scope=module)"),
-  tags: z16.array(z16.string()).default([]).describe("Tags for filtering"),
+  min_severity: z16.enum(["info", "minor", "major", "critical", "blocker"]).optional().describe("Ignore findings below this severity"),
+  limit: z16.number().int().positive().optional().describe("Cap the number of memories created"),
   author: z16.string().optional().describe("Author handle or email"),
-  force: z16.boolean().default(false).describe(
+  dry_run: z16.boolean().default(false).describe("When true, return the drafts that WOULD be created without writing them")
+};
+async function ingestFindings(input, ctx) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  let raw;
+  if (input.report && input.report.trim()) {
+    raw = input.report;
+  } else if (input.report_path) {
+    const file = path62.resolve(ctx.paths.root, input.report_path);
+    if (!existsSync16(file)) throw new Error(`Report file not found: ${file}`);
+    raw = await readFile32(file, "utf8");
+  } else {
+    throw new Error("Provide either `report_path` or `report`.");
+  }
+  const findings = parseFindings(input.format, raw);
+  const drafts = draftsFromFindings(findings, {
+    type: input.type,
+    scope: input.scope,
+    module: input.module,
+    author: input.author,
+    ...input.min_severity ? { minSeverity: input.min_severity } : {},
+    ...input.limit ? { limit: input.limit } : {}
+  });
+  const existing = existsSync16(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
+  const existingTopics = new Set(
+    existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
+  );
+  const fresh = filterNewDrafts(drafts, existingTopics);
+  const skipped = drafts.length - fresh.length;
+  const created = [];
+  for (const draft of fresh) {
+    let filePath;
+    if (!input.dry_run) filePath = await writeDraft(ctx, draft);
+    created.push({
+      id: draft.frontmatter.id,
+      topic: draft.topic,
+      path: draft.finding.path,
+      rule: draft.finding.ruleId,
+      severity: draft.finding.severity,
+      has_sensor: draft.has_sensor,
+      ...filePath ? { file_path: filePath } : {}
+    });
+  }
+  const notice = input.dry_run ? `Dry run \u2014 ${fresh.length} memory(ies) would be created (status=proposed). Re-run with dry_run=false to write them.` : `Created ${fresh.length} proposed memory(ies). They are NOT validated and their sensors are warn-only \u2014 review with mem_pending and promote with 'haive sensors promote'.`;
+  return {
+    format: input.format,
+    parsed: drafts.length,
+    new: fresh.length,
+    skipped_existing: skipped,
+    dry_run: input.dry_run,
+    created,
+    notice
+  };
+}
+async function writeDraft(ctx, draft) {
+  const file = memoryFilePath3(
+    ctx.paths,
+    draft.frontmatter.scope,
+    draft.frontmatter.id,
+    draft.frontmatter.module
+  );
+  await mkdir42(path62.dirname(file), { recursive: true });
+  await writeFile82(file, serializeMemory7({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  return file;
+}
+var MemObserveInputSchema = {
+  what: z17.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
+  where: z17.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
+  impact: z17.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
+  fix: z17.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
+  scope: z17.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+  module: z17.string().optional().describe("Module name (required when scope=module)"),
+  tags: z17.array(z17.string()).default([]).describe("Tags for filtering"),
+  author: z17.string().optional().describe("Author handle or email"),
+  force: z17.boolean().default(false).describe(
     "Save even if the observation looks like generic, guessable knowledge. By default, low-specificity observations (things a capable model already knows) are SKIPPED to keep the corpus high-signal \u2014 only unguessable, team-specific discoveries are worth storing."
   )
 };
 async function memObserve(input, ctx) {
-  if (!existsSync16(ctx.paths.haiveDir)) {
+  if (!existsSync17(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const signalText = [input.what, input.impact, input.fix ?? ""].join(" ");
@@ -4925,16 +5284,16 @@ async function memObserve(input, ctx) {
     lines.push("", `**Fix/workaround:** ${input.fix}`);
   }
   const body = lines.join("\n") + "\n";
-  const file = memoryFilePath3(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-  await mkdir42(path62.dirname(file), { recursive: true });
-  if (existsSync16(file)) {
+  const file = memoryFilePath4(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir52(path72.dirname(file), { recursive: true });
+  if (existsSync17(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
+  await writeFile92(file, serializeMemory8({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 function pendingDistillPath(ctx) {
-  return path72.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
+  return path82.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
 }
 var SessionTracker = class {
   events = [];
@@ -5013,7 +5372,7 @@ var SessionTracker = class {
         (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
       );
       const isSubstantialSession = totalCalls >= 3 || writingTools.length > 0;
-      if (!ranPostTask && isSubstantialSession && existsSync17(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync18(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -5026,9 +5385,9 @@ var SessionTracker = class {
             ...gitDiff ? { git_diff: gitDiff } : {},
             ...recapId ? { recap_id: recapId } : {}
           };
-          const cacheDir = path72.join(this.ctx.paths.haiveDir, ".cache");
-          await mkdir52(cacheDir, { recursive: true });
-          await writeFile92(
+          const cacheDir = path82.join(this.ctx.paths.haiveDir, ".cache");
+          await mkdir62(cacheDir, { recursive: true });
+          await writeFile10(
             pendingDistillPath(this.ctx),
             JSON.stringify(payload, null, 2) + "\n",
             "utf8"
@@ -5047,7 +5406,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync17(p)) {
+  if (existsSync18(p)) {
     try {
       await rm(p);
     } catch {
@@ -5062,15 +5421,15 @@ function summarizeTools(events) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([t, n]) => `${t} \xD7${n}`).join(", ");
 }
 var MemSessionEndInputSchema = {
-  goal: z17.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
-  accomplished: z17.string().describe("What was actually done \u2014 bullet list recommended"),
-  discoveries: z17.string().default("").describe(
+  goal: z18.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z18.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z18.string().default("").describe(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  files_touched: z17.array(z17.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
-  next_steps: z17.string().default("").describe("What should happen next (for the next session or a teammate)"),
-  scope: z17.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
-  module: z17.string().optional().describe("Module name (required when scope=module)")
+  files_touched: z18.array(z18.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z18.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z18.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z18.string().optional().describe("Module name (required when scope=module)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -5100,23 +5459,23 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync18(ctx.paths.haiveDir)) {
+  if (!existsSync19(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const body = buildBody(input);
   const topic = recapTopic(input.scope, input.module);
   const normalizedFiles = input.files_touched.map((p) => {
-    if (!p || !path82.isAbsolute(p)) return p;
-    const rel = path82.relative(ctx.paths.root, p);
+    if (!p || !path92.isAbsolute(p)) return p;
+    const rel = path92.relative(ctx.paths.root, p);
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync18(path82.resolve(ctx.paths.root, p))
+    (p) => !existsSync19(path92.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync18(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
+  const existing = existsSync19(ctx.paths.memoriesDir) ? await loadMemoriesFromDir14(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === input.scope && (!input.module || memory2.frontmatter.module === input.module)
   );
@@ -5132,9 +5491,9 @@ async function memSessionEnd(input, ctx) {
         paths: normalizedFiles.length ? normalizedFiles : fm.anchor.paths
       }
     };
-    await writeFile10(
+    await writeFile11(
       topicMatch.filePath,
-      serializeMemory8({ frontmatter: newFrontmatter, body }),
+      serializeMemory9({ frontmatter: newFrontmatter, body }),
       "utf8"
     );
     await clearPendingDistill(ctx);
@@ -5156,14 +5515,14 @@ async function memSessionEnd(input, ctx) {
     topic,
     status: "validated"
   });
-  const file = memoryFilePath4(
+  const file = memoryFilePath5(
     ctx.paths,
     frontmatter.scope,
     frontmatter.id,
     frontmatter.module
   );
-  await mkdir62(path82.dirname(file), { recursive: true });
-  await writeFile10(file, serializeMemory8({ frontmatter, body }), "utf8");
+  await mkdir72(path92.dirname(file), { recursive: true });
+  await writeFile11(file, serializeMemory9({ frontmatter, body }), "utf8");
   await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
@@ -5297,50 +5656,50 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync19(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync20(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
   const out = [];
   for (const m of modules) {
     if (!available.has(m)) continue;
-    const file = path92.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync19(file)) {
-      out.push({ name: m, content: await readFile32(file, "utf8") });
+    const file = path102.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync20(file)) {
+      out.push({ name: m, content: await readFile42(file, "utf8") });
     }
   }
   return out;
 }
 var GetBriefingInputSchema = {
-  task: z18.string().optional().describe(
+  task: z19.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z18.array(z18.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z18.number().int().positive().default(8e3).describe(
+  files: z19.array(z19.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z19.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: z18.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z18.boolean().default(true),
-  include_module_contexts: z18.boolean().default(true),
-  semantic: z18.boolean().default(true).describe(
+  max_memories: z19.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z19.boolean().default(true),
+  include_module_contexts: z19.boolean().default(true),
+  semantic: z19.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  include_stale: z18.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
-  track: z18.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z18.enum(["full", "compact", "actions"]).default("full").describe(
+  include_stale: z19.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z19.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z19.enum(["full", "compact", "actions"]).default("full").describe(
     "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
-  symbols: z18.array(z18.string()).default([]).describe(
+  symbols: z19.array(z19.string()).default([]).describe(
     "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
   ),
-  min_semantic_score: z18.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z19.number().min(0).max(1).default(0).describe(
     "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
   ),
-  budget_preset: z18.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z19.enum(["quick", "balanced", "deep"]).optional().describe(
     "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
-var GetBriefingZod = z18.object(GetBriefingInputSchema);
+var GetBriefingZod = z19.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget2(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -5356,8 +5715,8 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync20(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  if (existsSync21(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
     const recaps = allLoaded.filter(({ memory: memory2 }) => memory2.frontmatter.type === "session_recap").sort(
       (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
     );
@@ -5520,7 +5879,7 @@ async function getBriefing(input, ctx) {
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated" };
         try {
-          await writeFile11(loaded.filePath, serializeMemory9({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
+          await writeFile12(loaded.filePath, serializeMemory10({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -5528,12 +5887,12 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync20(ctx.paths.projectContext) ? await readFile42(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile52(ctx.paths.projectContext, "utf8") : "";
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync20(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync21(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap5(ctx.paths);
@@ -5694,8 +6053,8 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync20(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  if (existsSync21(ctx.paths.memoriesDir)) {
+    const allMems = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
     for (const { memory: memory2 } of allMems) {
       const fm = memory2.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -5705,9 +6064,9 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync20(pendingDistillFile)) {
+  if (existsSync21(pendingDistillFile)) {
     try {
-      const raw = await readFile42(pendingDistillFile, "utf8");
+      const raw = await readFile52(pendingDistillFile, "utf8");
       const pd = JSON.parse(raw);
       const ageMs = Date.now() - new Date(pd.session_end).getTime();
       const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1e3;
@@ -5734,7 +6093,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync20(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync21(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hasUnguessableSignal = outputMemories.some(
     (m) => (m.priority === "must_read" || m.priority === "useful") && specificityScore2(m.body) >= GUESSABLE_THRESHOLD
@@ -5781,7 +6140,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       "No team-specific policy matched these files/task \u2014 nothing here a capable model can't infer. The auto-generated project context was trimmed to keep this briefing near-zero-cost; proceed with normal Read/Grep."
     );
   }
-  if (existsSync20(ctx.paths.haiveDir)) {
+  if (existsSync21(ctx.paths.haiveDir)) {
     await writeBriefingMarker2(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -5830,17 +6189,17 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
   };
 }
 var CodeMapInputSchema = {
-  file: z19.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z19.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  paths: z19.array(z19.string()).default([]).describe(
+  file: z20.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z20.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  paths: z20.array(z20.string()).default([]).describe(
     "Filter to files under any of these path prefixes (e.g. ['packages/mcp/src/tools/', 'src/auth/']). OR-joined with `file` substring; useful to get a focused view of one module."
   ),
-  max_files: z19.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
-  max_tokens: z19.number().int().positive().optional().describe(
+  max_files: z20.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z20.number().int().positive().optional().describe(
     "Approximate token budget for the response. When the matching set exceeds it, files are ranked by export density (exports per LOC) and the highest-signal ones are kept first. Omit to disable budgeting (legacy behavior)."
   )
 };
-var CodeMapInputZod = z19.object(CodeMapInputSchema);
+var CodeMapInputZod = z20.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap22(ctx.paths);
   if (!map) {
@@ -5908,14 +6267,14 @@ function estimateFileEntryTokens(f) {
   return estimateTokens2(f.path) + estimateTokens2(f.entry.summary ?? "") + exportsCost + 4;
 }
 var MemDiffInputSchema = {
-  id_a: z20.string().min(1).describe("First memory id"),
-  id_b: z20.string().min(1).describe("Second memory id")
+  id_a: z21.string().min(1).describe("First memory id"),
+  id_b: z21.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync21(ctx.paths.memoriesDir)) {
+  if (!existsSync222(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
   const foundA = all.find((m) => m.memory.frontmatter.id === input.id_a);
   const foundB = all.find((m) => m.memory.frontmatter.id === input.id_b);
   if (!foundA) throw new Error(`No memory with id "${input.id_a}".`);
@@ -5948,15 +6307,15 @@ async function memDiff(input, ctx) {
   };
 }
 var GetRecapInputSchema = {
-  scope: z21.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z22.enum(["personal", "team", "any"]).default("any").describe(
     "Limit to a specific scope's recap. Default 'any' returns the most recent recap across both personal and team scopes."
   )
 };
 async function getRecap(input, ctx) {
-  if (!existsSync222(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
-  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
   const recaps = all.filter(({ memory: memory2 }) => memory2.frontmatter.type === "session_recap").filter(({ memory: memory2 }) => input.scope === "any" || memory2.frontmatter.scope === input.scope).sort(
     (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
   );
@@ -5979,11 +6338,11 @@ async function getRecap(input, ctx) {
   };
 }
 var MemRelevantToInputSchema = {
-  task: z22.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
-  files: z22.array(z22.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
-  limit: z22.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
-  min_semantic_score: z22.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
-  format: z22.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
+  task: z23.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z23.array(z23.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z23.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z23.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z23.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -6012,11 +6371,11 @@ async function memRelevantTo(input, ctx) {
   return out;
 }
 var CodeSearchInputSchema = {
-  query: z23.string().min(1).describe(
+  query: z24.string().min(1).describe(
     "Natural-language description of what you are looking for in the codebase (e.g. 'function that hashes passwords', 'JWT signing logic', 'route registration')."
   ),
-  k: z23.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
-  min_score: z23.number().min(0).max(1).default(0.2).describe(
+  k: z24.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z24.number().min(0).max(1).default(0.2).describe(
     "Minimum cosine similarity. Hits below this threshold are dropped to avoid noise. Try 0.3+ for stricter matching."
   )
 };
@@ -6045,14 +6404,14 @@ async function codeSearch(input, ctx) {
   return { available: true, hits: result.hits };
 }
 var WhyThisFileInputSchema = {
-  path: z24.string().min(1).describe(
+  path: z25.string().min(1).describe(
     "Project-relative path to the file you want context on (e.g. 'packages/mcp/src/tools/mem-save.ts')."
   ),
-  git_log_limit: z24.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
-  memory_limit: z24.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
+  git_log_limit: z25.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
+  memory_limit: z25.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync23(path102.join(ctx.paths.root, input.path));
+  const fileExists = existsSync24(path112.join(ctx.paths.root, input.path));
   const [commits, memories, codeMap] = await Promise.all([
     runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
     collectAnchoredMemories(ctx, input.path, input.memory_limit),
@@ -6093,8 +6452,8 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync23(ctx.paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  if (!existsSync24(ctx.paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex9(ctx.paths);
   const out = [];
   for (const { memory: memory2 } of all) {
@@ -6147,17 +6506,17 @@ function runCommand(cmd, args, cwd) {
   });
 }
 var AntiPatternsCheckInputSchema = {
-  diff: z25.string().optional().describe(
+  diff: z26.string().optional().describe(
     "Raw unified diff text (or any code/text snippet) to scan for previously documented anti-patterns. Tokens from the diff are used to match memory bodies and the embeddings index."
   ),
-  paths: z25.array(z25.string()).default([]).describe(
+  paths: z26.array(z26.string()).default([]).describe(
     "File paths affected by the change. Memories anchored to any of these paths are surfaced regardless of the diff content."
   ),
-  limit: z25.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
-  semantic: z25.boolean().default(true).describe(
+  limit: z26.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
+  semantic: z26.boolean().default(true).describe(
     "When true, also use semantic search (requires @hiveai/embeddings + memory index) to find related anti-patterns."
   ),
-  min_semantic_score: z25.number().min(0).max(1).default(0.45).describe(
+  min_semantic_score: z26.number().min(0).max(1).default(0.45).describe(
     "Minimum cosine score for semantic-only anti-pattern hits. Anchor/literal matches still surface. Default 0.45 keeps broad, weakly-related memories out of review noise."
   )
 };
@@ -6178,10 +6537,10 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync25(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
-  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory: memory2 }) => {
     const t = memory2.frontmatter.type;
@@ -6288,12 +6647,12 @@ async function antiPatternsCheck(input, ctx) {
   };
 }
 var MemDistillInputSchema = {
-  since_days: z26.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
-  min_cluster: z26.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
-  type_filter: z26.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
+  since_days: z27.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
+  min_cluster: z27.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
+  type_filter: z27.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
     "Memory type to scan. 'gotcha' targets observe-style discoveries that recur, 'attempt' surfaces failed approaches that repeat, 'all' considers both."
   ),
-  scope: z26.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
+  scope: z27.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
 };
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var STOP_WORDS = /* @__PURE__ */ new Set([
@@ -6333,11 +6692,11 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync25(ctx.paths.memoriesDir)) {
+  if (!existsSync26(ctx.paths.memoriesDir)) {
     return { scanned: 0, singletons: 0, clusters: [], notice: "No .ai/memories directory." };
   }
   const cutoff = Date.now() - input.since_days * MS_PER_DAY;
-  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -6440,11 +6799,11 @@ function firstHeading(body) {
   return void 0;
 }
 var WhyThisDecisionInputSchema = {
-  id: z27.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
-  git_log_limit: z27.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
+  id: z28.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
+  git_log_limit: z28.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -6453,7 +6812,7 @@ async function whyThisDecision(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex11(ctx.paths);
   const target = all.find(({ memory: memory2 }) => memory2.frontmatter.id === input.id);
   if (!target) {
@@ -6575,17 +6934,17 @@ function runCommand2(cmd, args, cwd) {
   });
 }
 var MemConflictsInputSchema = {
-  id: z28.string().min(1).describe("Memory id to check for conflicts."),
-  min_score: z28.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
-  semantic: z28.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
+  id: z29.string().min(1).describe("Memory id to check for conflicts."),
+  min_score: z29.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
+  semantic: z29.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
 };
 var POSITIVE_PATTERNS = /\b(use|prefer|always|should use|do this|recommended|ok to)\b/i;
 var NEGATIVE_PATTERNS = /\b(do not use|don'?t use|never|avoid|forbidden|deprecated|stop using|do NOT|❌)\b/i;
 async function memConflicts(input, ctx) {
-  if (!existsSync27(ctx.paths.memoriesDir)) {
+  if (!existsSync28(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
   const target = all.find(({ memory: memory2 }) => memory2.frontmatter.id === input.id);
   if (!target) {
     return { found: false, scanned: 0, conflicts: [], notice: `Memory '${input.id}' not found.` };
@@ -6696,15 +7055,15 @@ async function trySemanticSimilarities(ctx, target, others) {
   return map;
 }
 var PreCommitCheckInputSchema = {
-  diff: z29.string().optional().describe(
+  diff: z30.string().optional().describe(
     "Raw unified diff text to scan. If omitted, only `paths` is used. When called from a pre-commit hook, pipe the output of `git diff --cached`."
   ),
-  paths: z29.array(z29.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
-  block_on: z29.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
+  paths: z30.array(z30.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z30.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
     "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
   ),
-  semantic: z29.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z29.boolean().default(false).describe(
+  semantic: z30.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z30.boolean().default(false).describe(
     "When true, ALSO block a high-confidence anti-pattern (attempt/gotcha) that is anchored to a touched file AND corroborated by the diff (literal token overlap, or semantic >= 0.45) \u2014 not just very strong semantic matches. Powers the 'anchored' enforcement gate. Config/docs-only commits are still downgraded. Default false preserves the soft, semantic-only blocking behavior."
   )
 };
@@ -7010,12 +7369,12 @@ var CONFIG_PATTERNS = [
 var MAX_DIFF_BYTES = 4096;
 var HOT_FILE_MIN = 3;
 var PatternDetectInputSchema = {
-  since_days: z30.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
-  dry_run: z30.boolean().default(false).describe("When true, report matches without writing any memory files."),
-  scope: z30.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
+  since_days: z31.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
+  dry_run: z31.boolean().default(false).describe("When true, report matches without writing any memory files."),
+  scope: z31.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
 };
 async function patternDetect(input, ctx) {
-  if (!existsSync28(ctx.paths.haiveDir)) {
+  if (!existsSync29(ctx.paths.haiveDir)) {
     return {
       scanned_events: 0,
       matches: [],
@@ -7028,13 +7387,13 @@ async function patternDetect(input, ctx) {
   try {
     const changedFiles = gitChangedFiles(ctx.paths.root, input.since_days);
     const configFiles = changedFiles.filter(
-      (f) => CONFIG_PATTERNS.some((p) => path112.basename(f.toLowerCase()).includes(p))
+      (f) => CONFIG_PATTERNS.some((p) => path122.basename(f.toLowerCase()).includes(p))
     );
     for (const file of configFiles.slice(0, 5)) {
       const diff = gitFileDiff(ctx.paths.root, file, input.since_days);
       if (!diff) continue;
-      const parentDir = path112.basename(path112.dirname(file));
-      const baseName = path112.basename(file).replace(/\.[^.]+$/, "");
+      const parentDir = path122.basename(path122.dirname(file));
+      const baseName = path122.basename(file).replace(/\.[^.]+$/, "");
       const slug = `${parentDir}-${baseName}`.replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
       matches.push({
         kind: "config_change",
@@ -7098,7 +7457,7 @@ async function patternDetect(input, ctx) {
   for (const [p, { count, tools }] of pathCounts) {
     if (count < HOT_FILE_MIN) continue;
     if (tools.has("mem_tried") || tools.has("mem_observe")) continue;
-    if (CONFIG_PATTERNS.some((cp) => path112.basename(p).includes(cp))) continue;
+    if (CONFIG_PATTERNS.some((cp) => path122.basename(p).includes(cp))) continue;
     const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
     matches.push({
       kind: "hot_file",
@@ -7138,17 +7497,17 @@ async function patternDetect(input, ctx) {
         paths: match.anchor_paths,
         status: "proposed"
       });
-      const file = memoryFilePath5(
+      const file = memoryFilePath6(
         ctx.paths,
         fm.scope === "shared" ? "team" : fm.scope,
         fm.id,
         void 0
       );
-      if (existsSync28(file)) continue;
-      await mkdir72(path112.dirname(file), { recursive: true });
-      await writeFile12(
+      if (existsSync29(file)) continue;
+      await mkdir82(path122.dirname(file), { recursive: true });
+      await writeFile13(
         file,
-        serializeMemory10({ frontmatter: fm, body: match.proposed_body }),
+        serializeMemory11({ frontmatter: fm, body: match.proposed_body }),
         "utf8"
       );
       savedIds.push(fm.id);
@@ -7189,17 +7548,17 @@ function gitFileDiff(root, file, sinceDays) {
   }
 }
 var MemConflictCandidatesInputSchema = {
-  since_days: z31.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
-  types: z31.array(z31.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
-  min_jaccard: z31.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
-  max_pairs: z31.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
-  max_scan: z31.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: z31.number().int().positive().max(100).default(20).describe(
+  since_days: z32.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z32.array(z32.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z32.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z32.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z32.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: z32.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 (!existsSync29(ctx.paths.memoriesDir)) {
+  if (!existsSync30(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -7208,7 +7567,7 @@ async function memConflictCandidates(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -7221,7 +7580,7 @@ async function memConflictCandidates(input, ctx) {
   return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
 }
 var MemResolveProjectInputSchema = {
-  cwd: z32.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z33.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -7234,7 +7593,7 @@ async function memResolveProject(input, _ctx) {
 }
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z33.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z34.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -7242,15 +7601,15 @@ async function memSuggestTopic(input, _ctx) {
   return { topic_key: suggestion.topic_key, family: suggestion.family, type: input.type };
 }
 var MemTimelineInputSchema = {
-  memory_id: z34.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
-  topic: z34.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
-  limit: z34.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+  memory_id: z35.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z35.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z35.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync30(ctx.paths.memoriesDir)) {
+  if (!existsSync31(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir24(ctx.paths.memoriesDir);
   const { entries, notice } = collectTimelineEntries(all, {
     memoryId: input.memory_id,
     topic: input.topic,
@@ -7259,9 +7618,9 @@ async function memTimeline(input, ctx) {
   return { entries, total: entries.length, notice };
 }
 var RuntimeJournalAppendInputSchema = {
-  message: z35.string().min(1).describe("Short line to append to the runtime session journal"),
-  kind: z35.enum(["note", "session_end", "mcp"]).default("note"),
-  tool: z35.string().optional().describe("When kind=mcp, which tool name (optional)")
+  message: z36.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z36.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z36.string().optional().describe("When kind=mcp, which tool name (optional)")
 };
 async function runtimeJournalAppend(input, ctx) {
   await appendRuntimeJournalEntry2(ctx.paths, {
@@ -7275,7 +7634,7 @@ async function runtimeJournalAppend(input, ctx) {
   };
 }
 var RuntimeJournalTailInputSchema = {
-  limit: z36.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+  limit: z37.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);
@@ -7285,10 +7644,10 @@ async function runtimeJournalTail(input, ctx) {
   return { entries };
 }
 var BootstrapProjectArgsSchema = {
-  module: z37.string().optional().describe(
+  module: z38.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z37.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z38.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -7369,8 +7728,8 @@ ${template}\`\`\`
   };
 }
 var PostTaskArgsSchema = {
-  task_summary: z38.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z38.array(z38.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z39.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z39.array(z39.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -7466,10 +7825,10 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
   };
 }
 var ImportDocsArgsSchema = {
-  content: z39.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z39.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z39.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z39.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z40.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z40.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z40.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z40.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -7532,7 +7891,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.12.4";
+var SERVER_VERSION = "0.13.0";
 function jsonResult(data) {
   return {
     content: [
@@ -7575,7 +7934,8 @@ var MAINTENANCE_PROFILE_TOOLS = [
   "mem_distill",
   "mem_timeline",
   "mem_conflict_candidates",
-  "mem_feedback"
+  "mem_feedback",
+  "ingest_findings"
 ];
 var EXPERIMENTAL_PROFILE_TOOLS = [
   ...MAINTENANCE_PROFILE_TOOLS,
@@ -7609,7 +7969,8 @@ var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_delete",
   "mem_feedback",
   "runtime_journal_append",
-  "pattern_detect"
+  "pattern_detect",
+  "ingest_findings"
 ]);
 function createHaiveServer(options = {}) {
   const context = createContext(options);
@@ -7734,6 +8095,36 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memTried(input, context));
     }
   );
+  registerTool(
+    "ingest_findings",
+    [
+      "Turn scanner findings (SonarQube / SARIF) into proposed, anchored memories with sensors.",
+      "",
+      "USE THIS to seed hAIve from your existing quality tooling: each real defect a scanner",
+      "found becomes a `gotcha`/`convention` memory anchored to the file, pre-filled with a",
+      "conservative `warn` sensor \u2014 so the next agent is steered away from it before re-writing it.",
+      "This closes the review\u2194memory loop and kills the cold-start problem.",
+      "",
+      "SAFETY: drafts are status=proposed and sensors are warn-only + autogen. This tool NEVER",
+      "auto-validates and NEVER auto-blocks. A human reviews (mem_pending) and promotes the sensor.",
+      "",
+      "PARAMETERS:",
+      "  format       \u2014 'sarif' (ESLint/Semgrep/CodeQL) | 'sonar' (SonarQube issues JSON)",
+      "  report_path  \u2014 project-relative path to the report file (OR pass `report` inline)",
+      "  report       \u2014 inline JSON content (OR pass `report_path`)",
+      "  type         \u2014 gotcha (default) | convention",
+      "  scope        \u2014 team (default) | personal | module",
+      "  min_severity \u2014 drop findings below this severity",
+      "  dry_run      \u2014 preview what would be created without writing",
+      "",
+      "RETURNS: { format, parsed, new, skipped_existing, created[], notice }"
+    ].join("\n"),
+    IngestFindingsInputSchema,
+    async (input) => {
+      tracker.record("ingest_findings", `${input.format}:${input.report_path ?? "inline"}`);
+      return jsonResult(await ingestFindings(input, context));
+    }
+  );
   registerTool(
     "mem_observe",
     [
@@ -8530,8 +8921,8 @@ function registerMcp(program2) {
 
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { readFile as readFile9, writeFile as writeFile13, mkdir as mkdir10 } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
+import { readFile as readFile9, writeFile as writeFile14, mkdir as mkdir10 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
 import path15 from "path";
 import "commander";
 import {
@@ -8544,12 +8935,12 @@ import {
   isStackPackSeed as isStackPackSeed3,
   loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig4,
-  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadMemoriesFromDir as loadMemoriesFromDir25,
   loadUsageIndex as loadUsageIndex13,
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths9,
   resolveManifestFiles,
-  serializeMemory as serializeMemory11,
+  serializeMemory as serializeMemory12,
   trackDependencies,
   verifyAnchor as verifyAnchor2,
   watchContracts
@@ -8564,11 +8955,11 @@ function registerSync(program2) {
     "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").option(
     "--inject-bridge",
-    "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
+    "inject top validated memories into CLAUDE.md + AGENTS.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").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").option("--dry-run", "report what would change without writing any files").action(async (opts) => {
     const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync31(paths.memoriesDir)) {
+    if (!existsSync33(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -8587,14 +8978,14 @@ function registerSync(program2) {
     let promoted = 0;
     let autoApproved = 0;
     if (opts.verify !== false) {
-      const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir25(paths.memoriesDir);
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
             if (!dryRun) {
-              await writeFile13(
+              await writeFile14(
                 filePath,
-                serializeMemory11({
+                serializeMemory12({
                   frontmatter: {
                     ...memory2.frontmatter,
                     status: "validated",
@@ -8617,9 +9008,9 @@ function registerSync(program2) {
         if (result.stale) {
           if (memory2.frontmatter.status !== "stale") {
             if (!dryRun) {
-              await writeFile13(
+              await writeFile14(
                 filePath,
-                serializeMemory11({
+                serializeMemory12({
                   frontmatter: {
                     ...memory2.frontmatter,
                     status: "stale",
@@ -8635,9 +9026,9 @@ function registerSync(program2) {
           }
         } else if (memory2.frontmatter.status === "stale") {
           if (!dryRun) {
-            await writeFile13(
+            await writeFile14(
               filePath,
-              serializeMemory11({
+              serializeMemory12({
                 frontmatter: {
                   ...memory2.frontmatter,
                   status: "validated",
@@ -8654,7 +9045,7 @@ function registerSync(program2) {
       }
     }
     if (opts.promote !== false) {
-      const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir25(paths.memoriesDir);
       const usage = await loadUsageIndex13(paths);
       const nowMs = Date.now();
       for (const { memory: memory2, filePath } of memories) {
@@ -8665,9 +9056,9 @@ function registerSync(program2) {
           maxRejections: DEFAULT_AUTO_PROMOTE_RULE2.maxRejections
         })) {
           if (!dryRun) {
-            await writeFile13(
+            await writeFile14(
               filePath,
-              serializeMemory11({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
+              serializeMemory12({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
               "utf8"
             );
           }
@@ -8678,9 +9069,9 @@ function registerSync(program2) {
           const ageHours = (nowMs - new Date(fm.created_at).getTime()) / (1e3 * 60 * 60);
           if (ageHours >= autoApproveDelayHours) {
             if (!dryRun) {
-              await writeFile13(
+              await writeFile14(
                 filePath,
-                serializeMemory11({
+                serializeMemory12({
                   frontmatter: {
                     ...fm,
                     status: "validated",
@@ -8706,7 +9097,7 @@ function registerSync(program2) {
       for (const repair of repairs) log(ui.dim(`autopilot: ${repair.message}`));
     }
     const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
-    const draftMemories = (await loadMemoriesFromDir24(paths.memoriesDir)).filter(
+    const draftMemories = (await loadMemoriesFromDir25(paths.memoriesDir)).filter(
       (m) => m.memory.frontmatter.status === "draft"
     );
     const draftCount = draftMemories.length;
@@ -8722,9 +9113,18 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path15.resolve(opts.bridgeFile) : path15.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
-      await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
+      let bridgeTargets;
+      if (opts.bridgeFile) {
+        bridgeTargets = [path15.resolve(opts.bridgeFile)];
+      } else {
+        const agentsMd = path15.join(root, "AGENTS.md");
+        bridgeTargets = [path15.join(root, "CLAUDE.md")];
+        if (existsSync33(agentsMd)) bridgeTargets.push(agentsMd);
+      }
+      for (const bridgeFile of bridgeTargets) {
+        await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
+      }
     }
     if (sinceReport && !opts.quiet) {
       if (sinceReport.added.length > 0) {
@@ -8741,7 +9141,7 @@ function registerSync(program2) {
       }
     }
     if (!opts.quiet) {
-      const allForDecay = await loadMemoriesFromDir24(paths.memoriesDir);
+      const allForDecay = await loadMemoriesFromDir25(paths.memoriesDir);
       const usageForDecay = await loadUsageIndex13(paths);
       const decaying = allForDecay.filter(({ memory: memory2 }) => {
         const fm = memory2.frontmatter;
@@ -8831,9 +9231,9 @@ Attends une **confirmation explicite** avant d'agir.
                 if (!dryRun) {
                   const teamDir = path15.join(paths.memoriesDir, "team");
                   await mkdir10(teamDir, { recursive: true });
-                  await writeFile13(
+                  await writeFile14(
                     path15.join(teamDir, `${fm.id}.md`),
-                    serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+                    serializeMemory12({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                     "utf8"
                   );
                 }
@@ -8900,9 +9300,9 @@ Attends une **confirmation explicite** avant d'agir.
             if (!dryRun) {
               const teamDir = path15.join(paths.memoriesDir, "team");
               await mkdir10(teamDir, { recursive: true });
-              await writeFile13(
+              await writeFile14(
                 path15.join(teamDir, `${fm.id}.md`),
-                serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+                serializeMemory12({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                 "utf8"
               );
             }
@@ -8992,8 +9392,8 @@ function bridgeSummaryLine(body) {
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync31(memoriesDir)) return;
-  const all = await loadMemoriesFromDir24(memoriesDir);
+  if (!existsSync33(memoriesDir)) return;
+  const all = await loadMemoriesFromDir25(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
     if (memory2.frontmatter.type === "session_recap") return false;
@@ -9018,7 +9418,7 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync31(bridgeFile);
+  const fileExists = existsSync33(bridgeFile);
   let existing = fileExists ? await readFile9(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
@@ -9040,7 +9440,7 @@ ${BRIDGE_END}`;
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
-  await writeFile13(bridgeFile, updated, "utf8");
+  await writeFile14(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
       ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path15.relative(root, bridgeFile)}`)
@@ -9068,8 +9468,8 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile15 } from "fs/promises";
+import { existsSync as existsSync34 } from "fs";
 import path16 from "path";
 import "commander";
 import {
@@ -9077,10 +9477,10 @@ import {
   findProjectRoot as findProjectRoot13,
   inferModulesFromPaths as inferModulesFromPaths3,
   loadConfig as loadConfig5,
-  loadMemoriesFromDir as loadMemoriesFromDir25,
-  memoryFilePath as memoryFilePath6,
+  loadMemoriesFromDir as loadMemoriesFromDir26,
+  memoryFilePath as memoryFilePath7,
   resolveHaivePaths as resolveHaivePaths10,
-  serializeMemory as serializeMemory12,
+  serializeMemory as serializeMemory13,
   suggestSensorFromMemory as suggestSensorFromMemory3
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
@@ -9111,7 +9511,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").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("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").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("--activation-keyword <csv>", "skill only: comma-separated keywords that trigger progressive disclosure of this skill").option("--activation-glob <csv>", "skill only: comma-separated path globs that trigger this skill").option("--activation-always", "skill only: always surface this skill (no triggers needed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync33(paths.haiveDir)) {
+    if (!existsSync34(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9128,7 +9528,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) => !existsSync33(path16.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync34(path16.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}`);
@@ -9141,7 +9541,7 @@ function registerMemoryAdd(memory2) {
     const slug = slugify(opts.slug ?? opts.title ?? opts.topic ?? opts.body ?? `${opts.type}-memory`);
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync33(opts.bodyFile)) {
+      if (!existsSync34(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9157,9 +9557,9 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync33(paths.memoriesDir)) {
+    if (existsSync34(paths.memoriesDir)) {
       const incomingHash = createHash2("sha256").update(body.trim()).digest("hex").slice(0, 12);
-      const allForHash = await loadMemoriesFromDir25(paths.memoriesDir);
+      const allForHash = await loadMemoriesFromDir26(paths.memoriesDir);
       const hashDup = allForHash.find(
         ({ memory: memory3 }) => createHash2("sha256").update(memory3.body.trim()).digest("hex").slice(0, 12) === incomingHash && memory3.frontmatter.scope === scope
       );
@@ -9170,8 +9570,8 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync33(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir25(paths.memoriesDir);
+    if (opts.topic && existsSync34(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir26(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
       );
@@ -9191,7 +9591,7 @@ TODO \u2014 write the memory body.
         };
         const suggestedSensor = !newFrontmatter.sensor ? suggestSensorForCliMemory(opts.type, body, newFrontmatter.anchor.paths) : null;
         if (suggestedSensor) newFrontmatter.sensor = suggestedSensor;
-        await writeFile14(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile15(topicMatch.filePath, serializeMemory13({ frontmatter: newFrontmatter, body }), "utf8");
         ui.success(`Updated (topic upsert) ${path16.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         if (suggestedSensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(suggestedSensor.pattern)}`);
@@ -9215,15 +9615,15 @@ TODO \u2014 write the memory body.
       sensor: suggestSensorForCliMemory(opts.type, body, anchorPaths) ?? void 0,
       activation
     });
-    const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    const file = memoryFilePath7(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir11(path16.dirname(file), { recursive: true });
-    if (existsSync33(file)) {
+    if (existsSync34(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync33(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir25(paths.memoriesDir);
+    if (existsSync34(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir26(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
         const id = memory3.frontmatter.id.toLowerCase();
@@ -9234,7 +9634,7 @@ TODO \u2014 write the memory body.
         ui.warn("Consider updating one of these with `haive memory update` instead.");
       }
     }
-    await writeFile14(file, serializeMemory12({ frontmatter, body }), "utf8");
+    await writeFile15(file, serializeMemory13({ frontmatter, body }), "utf8");
     ui.success(`Created ${path16.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     if (frontmatter.sensor?.autogen) {
@@ -9314,14 +9714,14 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import path17 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot14, resolveHaivePaths as resolveHaivePaths11 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir26,
+  loadMemoriesFromDir as loadMemoriesFromDir27,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -9331,12 +9731,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("--limit <n>", "max memories to display").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
     const limit = opts.limit ? Math.max(1, parseInt(opts.limit, 10)) : void 0;
     const filtered = all.filter((m) => {
@@ -9405,26 +9805,26 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
+import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync36 } from "fs";
 import path18 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
-  memoryFilePath as memoryFilePath7,
+  memoryFilePath as memoryFilePath8,
   resolveHaivePaths as resolveHaivePaths12,
-  serializeMemory as serializeMemory13
+  serializeMemory as serializeMemory14
 } 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 = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync35(paths.memoriesDir)) {
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const teamAndModule = await loadMemoriesFromDir26(paths.memoriesDir);
+    const teamAndModule = await loadMemoriesFromDir27(paths.memoriesDir);
     const alreadyShared = teamAndModule.find(
       (m) => m.memory.frontmatter.id === id && (m.memory.frontmatter.scope === "team" || m.memory.frontmatter.scope === "module")
     );
@@ -9438,7 +9838,7 @@ function registerMemoryPromote(memory2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.personalDir);
+    const all = await loadMemoriesFromDir27(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.)`);
@@ -9453,9 +9853,9 @@ function registerMemoryPromote(memory2) {
       },
       body: found.memory.body
     };
-    const newPath = memoryFilePath7(paths, "team", updated.frontmatter.id);
+    const newPath = memoryFilePath8(paths, "team", updated.frontmatter.id);
     await mkdir12(path18.dirname(newPath), { recursive: true });
-    await writeFile15(newPath, serializeMemory13(updated), "utf8");
+    await writeFile16(newPath, serializeMemory14(updated), "utf8");
     await unlink2(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
     ui.info(`Now at ${path18.relative(root, newPath)}`);
@@ -9464,25 +9864,25 @@ function registerMemoryPromote(memory2) {
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync36 } from "fs";
-import { writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync37 } from "fs";
+import { writeFile as writeFile17 } from "fs/promises";
 import path19 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot16,
   resolveHaivePaths as resolveHaivePaths13,
-  serializeMemory as serializeMemory14
+  serializeMemory as serializeMemory15
 } 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 = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     if (opts.all || opts.pending) {
       const candidates = all.filter((m) => {
         const s = m.memory.frontmatter.status;
@@ -9499,7 +9899,7 @@ function registerMemoryApprove(memory2) {
           frontmatter: { ...found2.memory.frontmatter, status: "validated" },
           body: found2.memory.body
         };
-        await writeFile16(found2.filePath, serializeMemory14(next2), "utf8");
+        await writeFile17(found2.filePath, serializeMemory15(next2), "utf8");
         count++;
       }
       ui.success(`Approved ${count} memor${count === 1 ? "y" : "ies"} (status=validated)`);
@@ -9528,32 +9928,32 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile16(found.filePath, serializeMemory14(next), "utf8");
+    await writeFile17(found.filePath, serializeMemory15(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
     ui.info(path19.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
-import { readFile as readFile11, writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync37 } from "fs";
+import { readFile as readFile11, writeFile as writeFile18 } from "fs/promises";
+import { existsSync as existsSync38 } from "fs";
 import path20 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot17,
   resolveHaivePaths as resolveHaivePaths14,
-  serializeMemory as serializeMemory15
+  serializeMemory as serializeMemory16
 } 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("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").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("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").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 = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir26(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -9590,7 +9990,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync37(opts.bodyFile)) {
+      if (!existsSync38(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9611,9 +10011,9 @@ function registerMemoryUpdate(memory2) {
       ui.warn("Nothing to update \u2014 provide at least one option.");
       return;
     }
-    await writeFile17(
+    await writeFile18(
       loaded.filePath,
-      serializeMemory15({ frontmatter: newFrontmatter, body: newBody }),
+      serializeMemory16({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
     ui.success(`Updated ${path20.relative(root, loaded.filePath)}`);
@@ -9635,8 +10035,8 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync38 } from "fs";
+import { writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync39 } from "fs";
 import path21 from "path";
 import "commander";
 import {
@@ -9646,7 +10046,7 @@ import {
   isAutoPromoteEligible as isAutoPromoteEligible3,
   loadUsageIndex as loadUsageIndex14,
   resolveHaivePaths as resolveHaivePaths15,
-  serializeMemory as serializeMemory16
+  serializeMemory as serializeMemory17
 } from "@hiveai/core";
 function registerMemoryAutoPromote(memory2) {
   memory2.command("auto-promote").description("Promote eligible 'proposed' memories to 'validated' based on usage").option("--min-reads <n>", "minimum read_count to qualify", String(DEFAULT_AUTO_PROMOTE_RULE3.minReads)).option(
@@ -9656,7 +10056,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 = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync38(paths.memoriesDir)) {
+    if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9665,7 +10065,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 loadMemoriesFromDir26(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex14(paths);
     const eligible = memories.filter(
       ({ memory: memory3 }) => isAutoPromoteEligible3(memory3.frontmatter, getUsage12(usage, memory3.frontmatter.id), rule)
@@ -9688,7 +10088,7 @@ function registerMemoryAutoPromote(memory2) {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile18(filePath, serializeMemory16(next), "utf8");
+        await writeFile19(filePath, serializeMemory17(next), "utf8");
         written++;
       }
     }
@@ -9699,7 +10099,7 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 import path23 from "path";
 import "commander";
@@ -9712,12 +10112,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 = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    if (!existsSync40(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -9752,7 +10152,7 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path24 from "path";
 import "commander";
 import {
@@ -9768,12 +10168,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 = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync40(paths.memoriesDir)) {
+    if (!existsSync41(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex15(paths);
     const inferred = inferModulesFromPaths4(files);
     const byAnchor = [];
@@ -9880,7 +10280,7 @@ function printGroup(root, label, loaded, usage) {
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import path25 from "path";
 import "commander";
 import {
@@ -9895,13 +10295,13 @@ function registerMemoryHot(memory2) {
   ).option("--threshold <n>", "minimum read_count to qualify (default: 3)", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    if (!existsSync43(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 loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex16(paths);
     const candidates = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -9933,16 +10333,16 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir13, writeFile as writeFile19 } from "fs/promises";
-import { existsSync as existsSync43 } from "fs";
+import { mkdir as mkdir13, writeFile as writeFile20 } from "fs/promises";
+import { existsSync as existsSync44 } from "fs";
 import path26 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter8,
   findProjectRoot as findProjectRoot22,
-  memoryFilePath as memoryFilePath8,
+  memoryFilePath as memoryFilePath9,
   resolveHaivePaths as resolveHaivePaths19,
-  serializeMemory as serializeMemory17,
+  serializeMemory as serializeMemory18,
   suggestSensorFromMemory as suggestSensorFromMemory4
 } from "@hiveai/core";
 function registerMemoryTried(memory2) {
@@ -9964,7 +10364,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", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync43(paths.haiveDir)) {
+    if (!existsSync44(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9990,14 +10390,14 @@ function registerMemoryTried(memory2) {
     if (sensor) {
       frontmatter.sensor = sensor;
     }
-    const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir13(path26.dirname(file), { recursive: true });
-    if (existsSync43(file)) {
+    if (existsSync44(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile19(file, serializeMemory17({ frontmatter, body }), "utf8");
+    await writeFile20(file, serializeMemory18({ frontmatter, body }), "utf8");
     ui.success(`Recorded: ${path26.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
     if (sensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
@@ -10010,7 +10410,7 @@ function parseCsv4(value) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile13 } from "fs/promises";
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import path27 from "path";
 import "commander";
 import {
@@ -10050,7 +10450,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync44(paths.haiveDir)) {
+    if (!existsSync45(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10106,7 +10506,7 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import path28 from "path";
 import "commander";
 import {
@@ -10119,12 +10519,12 @@ function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex17(paths);
     const filterFn = ({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed" && mem.frontmatter.status !== "draft") return false;
@@ -10177,7 +10577,7 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import path29 from "path";
 import "commander";
 import {
@@ -10194,7 +10594,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 = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10205,7 +10605,7 @@ function registerMemoryQuery(memory2) {
       return;
     }
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const passesFilters2 = (mem) => {
       const fm = mem.frontmatter;
       if (opts.scope && fm.scope !== opts.scope) return false;
@@ -10252,8 +10652,8 @@ ${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 existsSync47 } from "fs";
+import { writeFile as writeFile21 } from "fs/promises";
+import { existsSync as existsSync48 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot26,
@@ -10261,27 +10661,27 @@ import {
   recordRejection as recordRejection3,
   resolveHaivePaths as resolveHaivePaths23,
   saveUsageIndex as saveUsageIndex4,
-  serializeMemory as serializeMemory18
+  serializeMemory as serializeMemory19
 } 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 = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir26(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    await writeFile20(
+    await writeFile21(
       loaded.filePath,
-      serializeMemory18({
+      serializeMemory19({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -10303,7 +10703,7 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import path30 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
@@ -10318,12 +10718,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 = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync49(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -10354,7 +10754,7 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import { readFile as readFile14 } from "fs/promises";
 import path31 from "path";
 import "commander";
@@ -10369,12 +10769,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 = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync49(paths.memoriesDir)) {
+    if (!existsSync50(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -10413,7 +10813,7 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 import path33 from "path";
 import "commander";
 import {
@@ -10427,12 +10827,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 = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync50(paths.memoriesDir)) {
+    if (!existsSync51(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex21(paths);
     const target = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (target.length === 0) {
@@ -10458,7 +10858,7 @@ function registerMemoryStats(memory2) {
 }
 
 // src/commands/memory-impact.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import "commander";
 import {
   compareImpact,
@@ -10475,12 +10875,12 @@ function registerMemoryImpact(memory2) {
   ).option("--id <id>", "show impact for a single memory id").option("--prune", "list only prune candidates (dead weight worth reviewing)", false).option("--tier <tier>", "filter to a tier: high | medium | low | dormant").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot30(opts.dir);
     const paths = resolveHaivePaths27(root);
-    if (!existsSync51(paths.memoriesDir)) {
+    if (!existsSync53(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usageIndex = await loadUsageIndex23(paths);
     let rows = all.filter((m) => !opts.id || m.memory.frontmatter.id === opts.id).map(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -10546,7 +10946,7 @@ function pad(value, width) {
 }
 
 // src/commands/memory-feedback.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 import "commander";
 import {
   computeImpact as computeImpact4,
@@ -10569,12 +10969,12 @@ function registerMemoryFeedback(memory2) {
     }
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths28(root);
-    if (!existsSync53(paths.memoriesDir)) {
+    if (!existsSync54(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const target = all.find((m) => m.memory.frontmatter.id === id);
     if (!target) {
       ui.error(`No memory with id '${id}'.`);
@@ -10600,14 +11000,14 @@ function registerMemoryFeedback(memory2) {
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync54 } from "fs";
+import { writeFile as writeFile23 } from "fs/promises";
+import { existsSync as existsSync55 } from "fs";
 import path34 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot32,
   resolveHaivePaths as resolveHaivePaths29,
-  serializeMemory as serializeMemory19,
+  serializeMemory as serializeMemory20,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
 function registerMemoryVerify(memory2) {
@@ -10616,7 +11016,7 @@ 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("--json", "emit machine-readable JSON (for CI / agents)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot32(opts.dir);
     const paths = resolveHaivePaths29(root);
-    if (!existsSync54(paths.memoriesDir)) {
+    if (!existsSync55(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -10625,7 +11025,7 @@ function registerMemoryVerify(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const targets = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (opts.id && targets.length === 0) {
       if (opts.json) {
@@ -10674,7 +11074,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification2(mem, result);
-        await writeFile21(filePath, serializeMemory19(next), "utf8");
+        await writeFile23(filePath, serializeMemory20(next), "utf8");
         updated++;
       }
     }
@@ -10737,7 +11137,7 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile15 } from "fs/promises";
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot33,
@@ -10749,12 +11149,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 = findProjectRoot33(opts.dir);
     const paths = resolveHaivePaths30(root);
-    if (!existsSync55(paths.haiveDir)) {
+    if (!existsSync56(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync55(opts.from)) {
+    if (!existsSync56(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -10787,15 +11187,15 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync56 } from "fs";
-import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
+import { existsSync as existsSync57 } from "fs";
+import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile24 } from "fs/promises";
 import path35 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
   findProjectRoot as findProjectRoot34,
   resolveHaivePaths as resolveHaivePaths31,
-  serializeMemory as serializeMemory20
+  serializeMemory as serializeMemory21
 } from "@hiveai/core";
 function parseChangelog(content) {
   const entries = [];
@@ -10862,7 +11262,7 @@ function registerMemoryImportChangelog(memory2) {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths31(root);
     const changelogPath = path35.resolve(root, opts.fromChangelog);
-    if (!existsSync56(changelogPath)) {
+    if (!existsSync57(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -10925,9 +11325,9 @@ function registerMemoryImportChangelog(memory2) {
         paths: [path35.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile23(
+      await writeFile24(
         path35.join(teamDir, `${fm.id}.md`),
-        serializeMemory20({ frontmatter: fm, body: lines.join("\n") }),
+        serializeMemory21({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
       console.log(ui.green(`  \u2713 ${fm.id}`));
@@ -10949,15 +11349,15 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync57 } from "fs";
-import { writeFile as writeFile24 } from "fs/promises";
+import { existsSync as existsSync58 } from "fs";
+import { writeFile as writeFile25 } from "fs/promises";
 import path36 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
   findProjectRoot as findProjectRoot35,
   getUsage as getUsage20,
-  loadMemoriesFromDir as loadMemoriesFromDir27,
+  loadMemoriesFromDir as loadMemoriesFromDir28,
   loadUsageIndex as loadUsageIndex25,
   resolveHaivePaths as resolveHaivePaths32
 } from "@hiveai/core";
@@ -10974,7 +11374,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 = findProjectRoot35(opts.dir);
     const paths = resolveHaivePaths32(root);
-    if (!existsSync57(paths.memoriesDir)) {
+    if (!existsSync58(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10982,7 +11382,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 loadMemoriesFromDir27(paths.memoriesDir);
+    const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const usage = await loadUsageIndex25(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -11047,7 +11447,7 @@ function registerMemoryDigest(program2) {
     const digest = lines.join("\n");
     if (opts.out) {
       const outPath = path36.resolve(process.cwd(), opts.out);
-      await writeFile24(outPath, digest, "utf8");
+      await writeFile25(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -11056,22 +11456,22 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync58 } from "fs";
+import { writeFile as writeFile26, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync59 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
   findProjectRoot as findProjectRoot36,
-  loadMemoriesFromDir as loadMemoriesFromDir28,
-  memoryFilePath as memoryFilePath9,
+  loadMemoriesFromDir as loadMemoriesFromDir29,
+  memoryFilePath as memoryFilePath10,
   resolveHaivePaths as resolveHaivePaths33,
-  serializeMemory as serializeMemory21
+  serializeMemory as serializeMemory23
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync58(obsFile)) return await buildGitAutoRecap(paths);
+  if (!existsSync59(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile17(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -11262,7 +11662,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 = findProjectRoot36(opts.dir);
     const paths = resolveHaivePaths33(root);
-    if (!existsSync58(paths.haiveDir)) {
+    if (!existsSync59(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -11295,7 +11695,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync58(path37.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync59(path37.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}`);
@@ -11303,11 +11703,11 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync58(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync59(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync58(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir28(paths.memoriesDir);
+    if (existsSync59(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir29(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
       );
@@ -11323,7 +11723,7 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile25(topicMatch.filePath, serializeMemory21({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile26(topicMatch.filePath, serializeMemory23({ frontmatter: newFrontmatter, body }), "utf8");
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
@@ -11343,9 +11743,9 @@ function registerSessionEnd(session2) {
       topic,
       status: "validated"
     });
-    const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    const file = memoryFilePath10(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir15(path37.dirname(file), { recursive: true });
-    await writeFile25(file, serializeMemory21({ frontmatter, body }), "utf8");
+    await writeFile26(file, serializeMemory23({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
@@ -11368,7 +11768,7 @@ function normalizeAnchorPath(root, filePath) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path38 from "path";
 import "commander";
@@ -11403,14 +11803,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 = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths34(root);
-    if (!existsSync59(paths.haiveDir)) {
+    if (!existsSync60(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
       const contractsDir = path38.join(paths.haiveDir, "contracts");
-      if (!existsSync59(contractsDir)) {
+      if (!existsSync60(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -11534,18 +11934,18 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync60 } from "fs";
-import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile26, copyFile } from "fs/promises";
+import { existsSync as existsSync61 } from "fs";
+import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile27, copyFile } from "fs/promises";
 import path39 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
   findProjectRoot as findProjectRoot38,
   loadConfig as loadConfig8,
-  loadMemoriesFromDir as loadMemoriesFromDir29,
+  loadMemoriesFromDir as loadMemoriesFromDir30,
   resolveHaivePaths as resolveHaivePaths35,
   saveConfig as saveConfig3,
-  serializeMemory as serializeMemory23
+  serializeMemory as serializeMemory24
 } from "@hiveai/core";
 function registerHub(program2) {
   const hub = program2.command("hub").description(
@@ -11568,7 +11968,7 @@ function registerHub(program2) {
     }
     const sharedDir = path39.join(absPath, ".ai", "memories", "shared");
     await mkdir16(sharedDir, { recursive: true });
-    await writeFile26(
+    await writeFile27(
       path39.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
@@ -11590,7 +11990,7 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile26(
+    await writeFile27(
       path39.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
@@ -11636,7 +12036,7 @@ Next steps:
       return;
     }
     const hubRoot = path39.resolve(root, config.hubPath);
-    if (!existsSync60(hubRoot)) {
+    if (!existsSync61(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -11644,7 +12044,7 @@ Next steps:
     const projectName = path39.basename(root);
     const destDir = path39.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir16(destDir, { recursive: true });
-    const all = await loadMemoriesFromDir29(paths.memoriesDir);
+    const all = await loadMemoriesFromDir30(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:"))
@@ -11662,7 +12062,7 @@ Next steps:
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
       const destPath = path39.join(destDir, fileName);
-      await writeFile26(destPath, serializeMemory23(memory2), "utf8");
+      await writeFile27(destPath, serializeMemory24(memory2), "utf8");
       pushed++;
     }
     console.log(ui.green(`\u2713 Pushed ${pushed} shared memor${pushed === 1 ? "y" : "ies"} to hub`));
@@ -11706,7 +12106,7 @@ Next steps:
     }
     const hubRoot = path39.resolve(root, config.hubPath);
     const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync60(hubSharedDir)) {
+    if (!existsSync61(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -11761,7 +12161,7 @@ Next steps:
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
     const sharedDir = path39.join(paths.memoriesDir, "shared");
-    if (existsSync60(sharedDir)) {
+    if (existsSync61(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
@@ -11773,7 +12173,7 @@ Next steps:
     } else {
       console.log(ui.dim("  No imported shared memories yet."));
     }
-    const all = await loadMemoriesFromDir29(paths.memoriesDir);
+    const all = await loadMemoriesFromDir30(paths.memoriesDir);
     const outgoing = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
     );
@@ -11783,20 +12183,20 @@ Next steps:
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
     void readFile18;
-    void writeFile26;
+    void writeFile27;
     void saveConfig3;
   });
 }
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync61 } from "fs";
-import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
+import { existsSync as existsSync63 } from "fs";
+import { mkdir as mkdir17, writeFile as writeFile28 } from "fs/promises";
 import path40 from "path";
 import {
   aggregateUsage,
   findProjectRoot as findProjectRoot39,
-  loadMemoriesFromDir as loadMemoriesFromDir30,
+  loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex26,
   parseSince,
   readUsageEvents as readUsageEvents2,
@@ -11868,8 +12268,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 (existsSync61(paths.memoriesDir)) {
-    const mems = await loadMemoriesFromDir30(paths.memoriesDir);
+  if (existsSync63(paths.memoriesDir)) {
+    const mems = await loadMemoriesFromDir31(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
       if (fm.type === "session_recap") memoryCount.total_skipped_session++;
@@ -11911,7 +12311,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     top_memory_reads: memoryHitsLeader,
     roi_hints: roiHints
   };
-  await writeFile27(outAbs, JSON.stringify(payload, null, 2), "utf8");
+  await writeFile28(outAbs, JSON.stringify(payload, null, 2), "utf8");
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
@@ -12088,8 +12488,8 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync63 } from "fs";
-import { readdir as readdir5, readFile as readFile19, writeFile as writeFile28 } from "fs/promises";
+import { existsSync as existsSync64 } from "fs";
+import { readdir as readdir5, readFile as readFile19, writeFile as writeFile29 } from "fs/promises";
 import path41 from "path";
 import "commander";
 import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot41 } from "@hiveai/core";
@@ -12106,7 +12506,7 @@ function registerBenchmark(program2) {
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
       const outFile = path41.isAbsolute(opts.out) ? opts.out : path41.join(root, opts.out);
-      await writeFile28(outFile, markdown, "utf8");
+      await writeFile29(outFile, markdown, "utf8");
       ui.success(`wrote ${path41.relative(process.cwd(), outFile)}`);
       return;
     }
@@ -12136,14 +12536,14 @@ function resolveBenchmarkRoot(dir) {
   return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync63(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync64(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const fixtureDir = path41.join(root, entry.name);
     const reportFile = path41.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync63(reportFile)) continue;
+    if (!existsSync64(reportFile)) continue;
     const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -12233,14 +12633,15 @@ function escapeRegExp(value) {
 }
 
 // src/commands/eval.ts
-import { readFile as readFile20, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync64 } from "fs";
+import { mkdir as mkdir18, readFile as readFile20, writeFile as writeFile30 } from "fs/promises";
+import { existsSync as existsSync65 } from "fs";
 import path43 from "path";
 import "commander";
 import {
   aggregateRetrieval,
   aggregateSensors,
   buildReport,
+  compareEvalReports,
   findProjectRoot as findProjectRoot42,
   resolveHaivePaths as resolveHaivePaths38,
   scoreRetrievalCase,
@@ -12250,10 +12651,10 @@ import {
 function registerEval(program2) {
   program2.command("eval").description(
     "Rigorous, repeatable quality eval: do the right memories surface (retrieval) and do the right sensors fire (catch-rate)? Emits a chiffr\xE9 0\u2013100 score. Uses .ai/eval cases via --spec, or auto-synthesizes cases from anchored memories."
-  ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("--baseline", "save this run as the baseline (.ai/eval/baseline.json) for future --compare", false).option("--compare", "diff this run against the saved baseline and print the delta", false).option("--baseline-file <path>", "baseline file to read/write (default: .ai/eval/baseline.json)").option("--fail-on-regression", "with --compare, exit non-zero if the score dropped vs the baseline", false).option("--regression-gate", "CI-safe gate: compare against the baseline IF one exists (fail on regression), else no-op", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot42(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync64(paths.memoriesDir)) {
+    if (!existsSync65(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12285,30 +12686,87 @@ function registerEval(program2) {
       sensorAgg = aggregateSensors(results);
     }
     const report = buildReport(retrievalAgg, sensorAgg);
-    if (opts.json) {
-      console.log(JSON.stringify({ root, k, spec_source: resolvedSpec.source, report }, null, 2));
-    } else {
-      const md = renderMarkdown2(root, k, resolvedSpec.source, report);
-      if (opts.out) {
-        const outFile = path43.isAbsolute(opts.out) ? opts.out : path43.join(root, opts.out);
-        await writeFile29(outFile, md, "utf8");
-        ui.success(`wrote ${path43.relative(process.cwd(), outFile)}`);
+    const baselineFile = opts.baselineFile ? path43.isAbsolute(opts.baselineFile) ? opts.baselineFile : path43.join(root, opts.baselineFile) : path43.join(root, ".ai", "eval", "baseline.json");
+    if (opts.baseline) {
+      const snapshot = {
+        saved_at: (/* @__PURE__ */ new Date()).toISOString(),
+        k,
+        spec_source: resolvedSpec.source,
+        report
+      };
+      await mkdir18(path43.dirname(baselineFile), { recursive: true });
+      await writeFile30(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
+      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path43.relative(root, baselineFile)}`);
+    }
+    let delta = null;
+    if (opts.compare || opts.regressionGate) {
+      if (!existsSync65(baselineFile)) {
+        if (opts.regressionGate) {
+          if (!opts.json) ui.info(`No baseline at ${path43.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`haive eval --baseline\` to enable it.`);
+        } else {
+          ui.error(`No baseline at ${path43.relative(root, baselineFile)}. Run \`haive eval --baseline\` first.`);
+          process.exitCode = 1;
+          return;
+        }
       } else {
-        console.log(md);
+        const snapshot = JSON.parse(await readFile20(baselineFile, "utf8"));
+        delta = compareEvalReports(snapshot.report, report);
       }
     }
-    if (opts.failUnder !== void 0) {
-      const threshold = Number(opts.failUnder);
-      if (Number.isNaN(threshold)) {
-        ui.error(`--fail-under expects a number, got "${opts.failUnder}"`);
-        process.exitCode = 1;
-      } else if (report.score < threshold) {
-        ui.error(`eval score ${report.score} is below --fail-under ${threshold}`);
-        process.exitCode = 1;
-      }
+    if (opts.json) {
+      console.log(JSON.stringify({ root, k, spec_source: resolvedSpec.source, report, ...delta ? { delta } : {} }, null, 2));
+      applyExitGates(opts, report, delta);
+      return;
     }
+    if (delta) {
+      console.log(renderDelta(delta));
+    }
+    const md = renderMarkdown2(root, k, resolvedSpec.source, report);
+    if (opts.out) {
+      const outFile = path43.isAbsolute(opts.out) ? opts.out : path43.join(root, opts.out);
+      await writeFile30(outFile, md, "utf8");
+      ui.success(`wrote ${path43.relative(process.cwd(), outFile)}`);
+    } else {
+      console.log(md);
+    }
+    applyExitGates(opts, report, delta);
   });
 }
+function applyExitGates(opts, report, delta) {
+  if (opts.failUnder !== void 0) {
+    const threshold = Number(opts.failUnder);
+    if (Number.isNaN(threshold)) {
+      ui.error(`--fail-under expects a number, got "${opts.failUnder}"`);
+      process.exitCode = 1;
+    } else if (report.score < threshold) {
+      ui.error(`eval score ${report.score} is below --fail-under ${threshold}`);
+      process.exitCode = 1;
+    }
+  }
+  if ((opts.failOnRegression || opts.regressionGate) && delta?.regressed) {
+    ui.error(`eval score regressed ${delta.score.baseline} \u2192 ${delta.score.current} (\u0394 ${delta.score.delta}) vs baseline`);
+    process.exitCode = 1;
+  }
+}
+function fmtDelta(label, m) {
+  if (!m) return null;
+  const sign = m.delta > 0 ? "+" : "";
+  const arrow = m.delta > 0 ? ui.green("\u25B2") : m.delta < 0 ? ui.red("\u25BC") : ui.dim("=");
+  return `  ${arrow} ${label.padEnd(12)} ${m.baseline} \u2192 ${m.current} ${ui.dim(`(${sign}${m.delta})`)}`;
+}
+function renderDelta(delta) {
+  const verdict = delta.regressed ? ui.red("REGRESSED") : delta.improved ? ui.green("IMPROVED") : ui.dim("UNCHANGED");
+  const lines = [ui.bold(`Eval vs baseline \u2014 ${verdict}`)];
+  for (const line of [
+    fmtDelta("score", delta.score),
+    fmtDelta("mean recall", delta.mean_recall),
+    fmtDelta("mrr", delta.mrr),
+    fmtDelta("catch-rate", delta.catch_rate)
+  ]) {
+    if (line) lines.push(line);
+  }
+  return lines.join("\n");
+}
 async function resolveSpec(opts, root, memoriesDir) {
   if (opts.spec) {
     const file = path43.resolve(opts.spec);
@@ -12316,10 +12774,10 @@ async function resolveSpec(opts, root, memoriesDir) {
     return { spec: JSON.parse(raw), source: file };
   }
   const defaultSpec = path43.join(root, ".ai", "eval", "spec.json");
-  if (existsSync64(defaultSpec)) {
+  if (existsSync65(defaultSpec)) {
     const raw = await readFile20(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
-    const memories2 = await loadMemoriesFromDir26(memoriesDir);
+    const memories2 = await loadMemoriesFromDir27(memoriesDir);
     const synthesized = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
     return {
       spec: {
@@ -12329,7 +12787,7 @@ async function resolveSpec(opts, root, memoriesDir) {
       source: ".ai/eval/spec.json + synthesized anchored retrieval"
     };
   }
-  const memories = await loadMemoriesFromDir26(memoriesDir);
+  const memories = await loadMemoriesFromDir27(memoriesDir);
   return {
     spec: { retrieval: synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly }) },
     source: "synthesized anchored retrieval"
@@ -12419,8 +12877,8 @@ function renderMarkdown2(root, k, source, report) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir18, writeFile as writeFile30 } from "fs/promises";
-import { existsSync as existsSync65 } from "fs";
+import { mkdir as mkdir19, writeFile as writeFile31 } from "fs/promises";
+import { existsSync as existsSync66 } from "fs";
 import path44 from "path";
 import "commander";
 import {
@@ -12428,12 +12886,12 @@ import {
   buildFrontmatter as buildFrontmatter11,
   findProjectRoot as findProjectRoot43,
   loadConfig as loadConfig9,
-  loadMemoriesFromDir as loadMemoriesFromDir31,
-  memoryFilePath as memoryFilePath10,
+  loadMemoriesFromDir as loadMemoriesFromDir33,
+  memoryFilePath as memoryFilePath11,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
   resolveHaivePaths as resolveHaivePaths39,
-  serializeMemory as serializeMemory24
+  serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -12499,7 +12957,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync65(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
+      const existing = existsSync66(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -12521,13 +12979,13 @@ function registerMemorySuggest(memory2) {
           status
         });
         const body = renderTemplate(s, fm.id, status);
-        const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir18(path44.dirname(file), { recursive: true });
-        if (existsSync65(file)) {
+        const file = memoryFilePath11(paths, fm.scope, fm.id, fm.module);
+        await mkdir19(path44.dirname(file), { recursive: true });
+        if (existsSync66(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path44.relative(root, file)}` });
           continue;
         }
-        await writeFile30(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
+        await writeFile31(file, serializeMemory25({ frontmatter: fm, body }), "utf8");
         created.push({ id: fm.id, file: path44.relative(root, file), query: s.query });
       }
       if (opts.json) {
@@ -12626,8 +13084,8 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync66 } from "fs";
-import { writeFile as writeFile31 } from "fs/promises";
+import { existsSync as existsSync67 } from "fs";
+import { writeFile as writeFile33 } from "fs/promises";
 import path45 from "path";
 import "commander";
 import {
@@ -12635,10 +13093,10 @@ import {
   getUsage as getUsage21,
   retirementSignal as retirementSignal2,
   loadConfig as loadConfig10,
-  loadMemoriesFromDir as loadMemoriesFromDir33,
+  loadMemoriesFromDir as loadMemoriesFromDir34,
   loadUsageIndex as loadUsageIndex27,
   resolveHaivePaths as resolveHaivePaths40,
-  serializeMemory as serializeMemory25
+  serializeMemory as serializeMemory26
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
 function registerMemoryArchive(memory2) {
@@ -12647,7 +13105,7 @@ function registerMemoryArchive(memory2) {
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m'). Default: enforcement.decayAfterDays or 180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--unread", "decay by unread-age ALONE (ignore anchor status) \u2014 more aggressive corpus hygiene", false).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 = findProjectRoot44(opts.dir);
     const paths = resolveHaivePaths40(root);
-    if (!existsSync66(paths.memoriesDir)) {
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12661,7 +13119,7 @@ function registerMemoryArchive(memory2) {
       return;
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY2;
-    const all = await loadMemoriesFromDir33(paths.memoriesDir);
+    const all = await loadMemoriesFromDir34(paths.memoriesDir);
     const usage = await loadUsageIndex27(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
@@ -12672,7 +13130,7 @@ function registerMemoryArchive(memory2) {
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const retired = retirementSignal2(fm, mem.body);
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync66(path45.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync67(path45.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage21(usage, fm.id);
@@ -12721,7 +13179,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile31(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile33(c.filePath, serializeMemory26({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -12747,8 +13205,8 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync67, statSync as statSync2 } from "fs";
-import { readFile as readFile21, stat, writeFile as writeFile33 } from "fs/promises";
+import { existsSync as existsSync68, statSync as statSync2 } from "fs";
+import { readFile as readFile21, stat, writeFile as writeFile34 } from "fs/promises";
 import path46 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
@@ -12759,7 +13217,7 @@ import {
   isStackPackSeed as isStackPackSeed4,
   loadCodeMap as loadCodeMap7,
   loadConfig as loadConfig11,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
   loadUsageIndex as loadUsageIndex28,
   readUsageEvents as readUsageEvents4,
   resolveHaivePaths as resolveHaivePaths41
@@ -12774,7 +13232,7 @@ function registerDoctor(program2) {
     const findings = [];
     const repairs = [];
     const config = await loadConfig11(paths);
-    if (!existsSync67(paths.haiveDir)) {
+    if (!existsSync68(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -12795,7 +13253,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync67(paths.projectContext)) {
+    if (!existsSync68(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -12803,8 +13261,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile25 } = await import("fs/promises");
-      const content = await readFile25(paths.projectContext, "utf8");
+      const { readFile: readFile26 } = await import("fs/promises");
+      const content = await readFile26(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -12824,7 +13282,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync67(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const memories = existsSync68(paths.memoriesDir) ? await loadMemoriesFromDir35(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12976,10 +13434,10 @@ function registerDoctor(program2) {
     if (config.enforcement?.requireBriefingFirst) {
       const claudeSettings = path46.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync67(claudeSettings)) {
+      if (existsSync68(claudeSettings)) {
         try {
-          const { readFile: readFile25 } = await import("fs/promises");
-          const raw = await readFile25(claudeSettings, "utf8");
+          const { readFile: readFile26 } = await import("fs/promises");
+          const raw = await readFile26(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -13002,7 +13460,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.12.4"));
+    findings.push(...await collectInstallFindings(root, "0.13.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -13010,7 +13468,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.12.4";
+      const cliVersion = "0.13.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -13032,14 +13490,14 @@ npm uninstall -g @hiveai/mcp`
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync67(cfgPath)) continue;
+        if (!existsSync68(cfgPath)) continue;
         try {
           const raw = await readFile21(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
             staleConfigs.push(path46.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
-              await writeFile33(cfgPath, updated, "utf8");
+              await writeFile34(cfgPath, updated, "utf8");
             }
           }
         } catch {
@@ -13328,7 +13786,7 @@ which -a haive`
   ];
   for (const rel of integrationFiles) {
     const file = path46.join(root, rel);
-    if (!existsSync67(file)) continue;
+    if (!existsSync68(file)) continue;
     const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -13376,7 +13834,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
   const isHaiveWorkspace = (await readJson(path46.join(root, "package.json")))?.name === "haive-monorepo";
   if (!isHaiveWorkspace) return findings;
   const cliDist = path46.join(root, "packages/cli/dist/index.js");
-  if (!existsSync67(cliDist)) {
+  if (!existsSync68(cliDist)) {
     findings.push({
       severity: "warn",
       code: "workspace-dist-missing",
@@ -13400,7 +13858,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
     "packages/core/src/index.ts",
     "packages/mcp/src/server.ts",
     "packages/cli/src/index.ts"
-  ].map((rel) => path46.join(root, rel)).filter(existsSync67);
+  ].map((rel) => path46.join(root, rel)).filter(existsSync68);
   if (sourceFiles.length > 0) {
     const distMtime = statSync2(cliDist).mtimeMs;
     const newestSource = Math.max(...sourceFiles.map((file) => statSync2(file).mtimeMs));
@@ -13489,7 +13947,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync67(file)) return null;
+  if (!existsSync68(file)) return null;
   try {
     return JSON.parse(await readFile21(file, "utf8"));
   } catch {
@@ -13560,11 +14018,11 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot46,
-  loadMemoriesFromDir as loadMemoriesFromDir35,
+  loadMemoriesFromDir as loadMemoriesFromDir36,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
   resolveHaivePaths as resolveHaivePaths42
@@ -13590,7 +14048,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 = existsSync68(paths.memoriesDir) ? await loadMemoriesFromDir35(paths.memoriesDir) : [];
+    const all = existsSync69(paths.memoriesDir) ? await loadMemoriesFromDir36(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);
@@ -13832,11 +14290,11 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot48,
-  loadMemoriesFromDir as loadMemoriesFromDir36,
+  loadMemoriesFromDir as loadMemoriesFromDir37,
   resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 var TYPE_RANK = {
@@ -13854,12 +14312,12 @@ function registerWelcome(program2) {
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot48(opts.dir);
     const paths = resolveHaivePaths44(root);
-    if (!existsSync69(paths.memoriesDir)) {
+    if (!existsSync70(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir36(paths.memoriesDir);
+    const all = await loadMemoriesFromDir37(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"
     );
@@ -13926,7 +14384,7 @@ function registerResolveProject(program2) {
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 import path48 from "path";
 import "commander";
 import {
@@ -13952,7 +14410,7 @@ function registerRuntime(program2) {
     const root = path48.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths45(findProjectRoot49(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync70(paths.haiveDir)) {
+    if (!existsSync71(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -13967,7 +14425,7 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import path49 from "path";
 import "commander";
 import {
@@ -13986,13 +14444,13 @@ function registerMemoryTimeline(memory2) {
     }
     const root = path49.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths46(findProjectRoot50(root));
-    if (!existsSync71(paths.memoriesDir)) {
+    if (!existsSync73(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 loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const { entries, notice } = collectTimelineEntries2(all, {
       memoryId: opts.id,
       topic: opts.topic,
@@ -14004,7 +14462,7 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync73 } from "fs";
+import { existsSync as existsSync74 } from "fs";
 import path50 from "path";
 import "commander";
 import {
@@ -14029,7 +14487,7 @@ function registerMemoryConflictCandidates(memory2) {
   ).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 = path50.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths47(findProjectRoot51(root));
-    if (!existsSync73(paths.memoriesDir)) {
+    if (!existsSync74(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -14039,7 +14497,7 @@ function registerMemoryConflictCandidates(memory2) {
     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 loadMemoriesFromDir26(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const lexical = findLexicalConflictPairs2(all, {
       sinceDays,
       types: parseTypes(opts.types),
@@ -14065,8 +14523,8 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync74, statSync as statSync3 } from "fs";
-import { chmod as chmod2, mkdir as mkdir19, readFile as readFile23, readdir as readdir6, rm as rm3, writeFile as writeFile34 } from "fs/promises";
+import { existsSync as existsSync75, statSync as statSync3 } from "fs";
+import { chmod as chmod2, mkdir as mkdir20, readFile as readFile23, readdir as readdir6, rm as rm3, writeFile as writeFile35 } from "fs/promises";
 import path51 from "path";
 import "commander";
 import {
@@ -14075,7 +14533,7 @@ import {
   hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig13,
-  loadMemoriesFromDir as loadMemoriesFromDir37,
+  loadMemoriesFromDir as loadMemoriesFromDir38,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
@@ -14094,7 +14552,7 @@ function registerEnforce(program2) {
   enforce.command("install").description("Install hAIve enforcement across MCP config, git hooks, CI template, and supported client hooks.").option("-d, --dir <dir>", "project root").option("--no-git", "skip git pre-commit/pre-push enforcement hooks").option("--no-claude", "skip Claude Code hooks").option("--no-ci", "skip GitHub Actions enforcement workflow").action(async (opts) => {
     const root = findProjectRoot52(opts.dir);
     const paths = resolveHaivePaths48(root);
-    await mkdir19(paths.haiveDir, { recursive: true });
+    await mkdir20(paths.haiveDir, { recursive: true });
     const current = await loadConfig13(paths);
     await saveConfig4(paths, {
       ...current,
@@ -14140,14 +14598,14 @@ function registerEnforce(program2) {
     const root = findProjectRoot52(opts.dir);
     const paths = resolveHaivePaths48(root);
     const cacheDir = path51.join(paths.haiveDir, ".cache");
-    if (existsSync74(cacheDir)) {
+    if (existsSync75(cacheDir)) {
       if (opts.dryRun) ui.info(`would clean ${path51.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
         ui.success(`cleaned ${path51.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync74(paths.runtimeDir)) {
+    if (existsSync75(paths.runtimeDir)) {
       if (opts.dryRun) ui.info(`would clean ${path51.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
@@ -14172,8 +14630,8 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths48(root);
-    if (!existsSync74(paths.haiveDir)) return;
-    await mkdir19(paths.runtimeDir, { recursive: true });
+    if (!existsSync75(paths.haiveDir)) return;
+    await mkdir20(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
     await applyLightweightRepairs(root, paths);
@@ -14235,7 +14693,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths48(root);
-    if (!existsSync74(paths.haiveDir)) return;
+    if (!existsSync75(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker2(paths, payload.session_id);
     if (ok) {
@@ -14279,7 +14737,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
 async function buildFinishReport(dir) {
   const root = findProjectRoot52(dir);
   const paths = resolveHaivePaths48(root);
-  const initialized = existsSync74(paths.haiveDir);
+  const initialized = existsSync75(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -14477,7 +14935,7 @@ function finishReport(root, initialized, mode, findings, config) {
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot52(opts.dir);
   const paths = resolveHaivePaths48(root);
-  if (!existsSync74(paths.haiveDir)) {
+  if (!existsSync75(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -14547,7 +15005,7 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     memoryIds: briefing.memories.map((m) => m.id)
   });
   const dir = path51.join(paths.runtimeDir, "enforcement", "briefings");
-  await mkdir19(dir, { recursive: true });
+  await mkdir20(dir, { recursive: true });
   const file = path51.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
@@ -14566,13 +15024,13 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile34(file, parts.join("\n") + "\n", "utf8");
+  await writeFile35(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot52(dir);
   const paths = resolveHaivePaths48(root);
-  const initialized = existsSync74(paths.haiveDir);
+  const initialized = existsSync75(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
@@ -14603,7 +15061,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.12.4"));
+  findings.push(...await inspectIntegrationVersions(root, "0.13.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -14673,8 +15131,8 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync74(paths.memoriesDir)) return false;
-  const all = await loadMemoriesFromDir37(paths.memoriesDir);
+  if (!existsSync75(paths.memoriesDir)) return false;
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     const freshnessDate = fm.verified_at ?? fm.created_at;
@@ -14682,8 +15140,8 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync74(paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir37(paths.memoriesDir);
+  if (!existsSync75(paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
   let verified = 0;
@@ -14720,12 +15178,12 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync74(paths.memoriesDir)) return [];
+  if (!existsSync75(paths.memoriesDir)) return [];
   const changedFiles = await getChangedFiles(paths.root, stage);
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
   }
-  const all = await loadMemoriesFromDir37(paths.memoriesDir);
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
   const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const fm = memory2.frontmatter;
@@ -14829,7 +15287,7 @@ function isGeneratedArtifactStatusLine(line) {
 }
 async function cleanupRuntimeDir(runtimeDir) {
   let removed = 0;
-  await mkdir19(runtimeDir, { recursive: true });
+  await mkdir20(runtimeDir, { recursive: true });
   const entries = await readdir6(runtimeDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore" || entry.name === "README.md") continue;
@@ -14840,9 +15298,9 @@ async function cleanupRuntimeDir(runtimeDir) {
     await rm3(path51.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile34(path51.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync74(path51.join(runtimeDir, "README.md"))) {
-    await writeFile34(
+  await writeFile35(path51.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync75(path51.join(runtimeDir, "README.md"))) {
+    await writeFile35(
       path51.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
@@ -14852,14 +15310,14 @@ async function cleanupRuntimeDir(runtimeDir) {
 }
 async function cleanupCacheDir(cacheDir) {
   let removed = 0;
-  await mkdir19(cacheDir, { recursive: true });
+  await mkdir20(cacheDir, { recursive: true });
   const entries = await readdir6(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
     await rm3(path51.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile34(path51.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile35(path51.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -14884,7 +15342,7 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const findings = [];
   for (const rel of files) {
     const file = path51.join(root, rel);
-    if (!existsSync74(file)) continue;
+    if (!existsSync75(file)) continue;
     const text = await readFile23(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -14994,7 +15452,7 @@ async function resolveCiDiffRange(root) {
 }
 async function resolveGithubEventRange(root) {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !existsSync74(eventPath)) return null;
+  if (!eventPath || !existsSync75(eventPath)) return null;
   try {
     const event = JSON.parse(await readFile23(eventPath, "utf8"));
     const prBase = cleanGitSha(event.pull_request?.base?.sha);
@@ -15277,11 +15735,11 @@ function buildScore(findings, threshold = 80) {
 }
 async function installGitEnforcement(root) {
   const hooksDir = path51.join(root, ".git", "hooks");
-  if (!existsSync74(path51.join(root, ".git"))) {
+  if (!existsSync75(path51.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
-  await mkdir19(hooksDir, { recursive: true });
+  await mkdir20(hooksDir, { recursive: true });
   const hooks = [
     {
       name: "pre-commit",
@@ -15300,17 +15758,17 @@ haive enforce check --stage pre-push --dir . || exit $?
   ];
   for (const hook of hooks) {
     const file = path51.join(hooksDir, hook.name);
-    if (existsSync74(file)) {
+    if (existsSync75(file)) {
       const current = await readFile23(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile34(file, hook.body, "utf8");
+        await writeFile35(file, hook.body, "utf8");
       } else {
-        await writeFile34(file, `${current.trimEnd()}
+        await writeFile35(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile34(file, hook.body, "utf8");
+      await writeFile35(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
@@ -15318,12 +15776,12 @@ ${hook.body}`, "utf8");
 }
 async function installCiEnforcement(root) {
   const workflowPath = path51.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path51.dirname(workflowPath), { recursive: true });
-  if (existsSync74(workflowPath)) {
+  await mkdir20(path51.dirname(workflowPath), { recursive: true });
+  if (existsSync75(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile34(workflowPath, `name: haive-enforcement
+  await writeFile35(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -15451,11 +15909,11 @@ function normalizeToolPath(file, root) {
   return path51.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync74(paths.memoriesDir)) return [];
+  if (!existsSync75(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
-  const all = await loadMemoriesFromDir37(paths.memoriesDir);
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   return all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
@@ -15525,19 +15983,19 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile2 } from "child_process";
-import { existsSync as existsSync75 } from "fs";
-import { chmod as chmod3, mkdir as mkdir20, readFile as readFile24, writeFile as writeFile35 } from "fs/promises";
+import { existsSync as existsSync76 } from "fs";
+import { chmod as chmod3, mkdir as mkdir21, readFile as readFile24, writeFile as writeFile36 } from "fs/promises";
 import path53 from "path";
 import { promisify as promisify2 } from "util";
 import "commander";
 import {
   findProjectRoot as findProjectRoot53,
   isRetiredMemory as isRetiredMemory3,
-  loadMemoriesFromDir as loadMemoriesFromDir38,
+  loadMemoriesFromDir as loadMemoriesFromDir39,
   resolveHaivePaths as resolveHaivePaths49,
   runSensors as runSensors2,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
-  serializeMemory as serializeMemory26
+  serializeMemory as serializeMemory27
 } from "@hiveai/core";
 var exec2 = promisify2(execFile2);
 function registerSensors(program2) {
@@ -15608,7 +16066,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot53(opts.dir);
     const paths = resolveHaivePaths49(root);
-    const loaded = existsSync75(paths.memoriesDir) ? await loadMemoriesFromDir38(paths.memoriesDir) : [];
+    const loaded = existsSync76(paths.memoriesDir) ? await loadMemoriesFromDir39(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -15628,7 +16086,7 @@ function registerSensors(program2) {
       },
       body: found.memory.body
     };
-    await writeFile35(found.filePath, serializeMemory26(next), "utf8");
+    await writeFile36(found.filePath, serializeMemory27(next), "utf8");
     ui.success(`Updated ${id}: sensor severity=${severity}`);
     if (sensor.pattern) ui.info(`pattern=${JSON.stringify(sensor.pattern)}`);
     ui.info(`message=${sensor.message}`);
@@ -15644,10 +16102,10 @@ function registerSensors(program2) {
     const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
     const outDir = path53.resolve(root, opts.outDir ?? ".ai/generated");
-    await mkdir20(outDir, { recursive: true });
+    await mkdir21(outDir, { recursive: true });
     const outPath = path53.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
     const content = format === "grep" ? renderGrepScript(rows) : JSON.stringify({ sensors: rows }, null, 2) + "\n";
-    await writeFile35(outPath, content, "utf8");
+    await writeFile36(outPath, content, "utf8");
     if (format === "grep") await chmod3(outPath, 493);
     ui.success(`Exported ${rows.length} sensor(s): ${path53.relative(root, outPath)}`);
   });
@@ -15670,8 +16128,8 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync75(paths.memoriesDir)) return [];
-  const loaded = await loadMemoriesFromDir38(paths.memoriesDir);
+  if (!existsSync76(paths.memoriesDir)) return [];
+  const loaded = await loadMemoriesFromDir39(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
     if (!sensor) return false;
@@ -15711,9 +16169,305 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
+// src/commands/ingest.ts
+import { existsSync as existsSync77 } from "fs";
+import { mkdir as mkdir23, readFile as readFile25, writeFile as writeFile37 } from "fs/promises";
+import path54 from "path";
+import "commander";
+import {
+  draftsFromFindings as draftsFromFindings2,
+  filterNewDrafts as filterNewDrafts2,
+  findProjectRoot as findProjectRoot54,
+  loadMemoriesFromDir as loadMemoriesFromDir40,
+  memoryFilePath as memoryFilePath12,
+  parseFindings as parseFindings2,
+  resolveHaivePaths as resolveHaivePaths50,
+  serializeMemory as serializeMemory28
+} from "@hiveai/core";
+var SEVERITIES = ["info", "minor", "major", "critical", "blocker"];
+function registerIngest(program2) {
+  program2.command("ingest").description(
+    "Ingest scanner findings (SonarQube / SARIF) as proposed, anchored memories with sensors.\n\n  Closes the review\u2194memory loop: a real defect a scanner found becomes a `gotcha`/`convention`\n  memory anchored to the file, pre-filled with a conservative `warn` sensor, so the next agent\n  is steered away from it. Drafts are status=proposed; a human validates/promotes them.\n\n  `sonar-api` fetches issues live over plain HTTPS from any SonarQube/SonarCloud instance \u2014\n  no MCP or special setup required, just a URL + token you provide (or SONAR_HOST_URL /\n  SONAR_TOKEN env). If you don't use it, file-based ingest works exactly the same.\n\n  Example:\n    haive ingest --from sarif eslint.sarif --dry-run\n    haive ingest --from sonar sonar-issues.json --scope team --min-severity major\n    haive ingest --from sonar-api --sonar-component my_project --min-severity major\n"
+  ).argument("[file]", "path to the findings report JSON (required for --from sarif|sonar)").requiredOption("--from <format>", "report format: sarif | sonar | sonar-api").option("--dry-run", "show what would be created without writing", false).option("--scope <scope>", "memory scope: personal | team | module", "team").option("--module <name>", "module name (required when scope=module)").option("--type <type>", "memory type: gotcha | convention", "gotcha").option("--min-severity <severity>", "ignore findings below this severity (info|minor|major|critical|blocker)").option("--limit <n>", "cap the number of memories created").option("--author <author>", "author email or handle").option("--json", "emit JSON", false).option("--sonar-url <url>", "SonarQube base URL for --from sonar-api (or env SONAR_HOST_URL)").option("--sonar-token <token>", "SonarQube token for --from sonar-api (or env SONAR_TOKEN)").option("--sonar-component <key>", "SonarQube project/component key for --from sonar-api").option("--sonar-branch <branch>", "optional SonarQube branch for --from sonar-api").option("-d, --dir <dir>", "project root").action(async (file, opts) => {
+    const format = opts.from;
+    if (format !== "sarif" && format !== "sonar" && format !== "sonar-api") {
+      ui.error("--from must be sarif, sonar, or sonar-api");
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.type && opts.type !== "gotcha" && opts.type !== "convention") {
+      ui.error("--type must be gotcha or convention");
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.minSeverity && !SEVERITIES.includes(opts.minSeverity)) {
+      ui.error(`--min-severity must be one of: ${SEVERITIES.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const root = findProjectRoot54(opts.dir);
+    const paths = resolveHaivePaths50(root);
+    if (!existsSync77(paths.haiveDir)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const parseFormat = format === "sarif" ? "sarif" : "sonar";
+    let raw;
+    if (format === "sonar-api") {
+      const fetched = await fetchSonarIssues(opts);
+      if (!fetched.ok) {
+        ui.error(fetched.error);
+        process.exitCode = 1;
+        return;
+      }
+      raw = fetched.json;
+    } else {
+      if (!file) {
+        ui.error(`--from ${format} needs a report file argument, e.g. \`haive ingest --from ${format} report.json\`.`);
+        process.exitCode = 1;
+        return;
+      }
+      const reportPath = path54.resolve(root, file);
+      if (!existsSync77(reportPath)) {
+        ui.error(`Report file not found: ${reportPath}`);
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        raw = await readFile25(reportPath, "utf8");
+      } catch (err) {
+        ui.error(`Could not read ${reportPath}: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    let drafts;
+    try {
+      const findings = parseFindings2(parseFormat, raw);
+      drafts = draftsFromFindings2(findings, {
+        type: opts.type ?? "gotcha",
+        scope: opts.scope ?? "team",
+        module: opts.module,
+        author: opts.author,
+        ...opts.minSeverity ? { minSeverity: opts.minSeverity } : {},
+        ...opts.limit ? { limit: Math.max(0, Number.parseInt(opts.limit, 10) || 0) } : {}
+      });
+    } catch (err) {
+      ui.error(`Failed to parse ${format} report: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+      return;
+    }
+    const existing = existsSync77(paths.memoriesDir) ? await loadMemoriesFromDir40(paths.memoriesDir) : [];
+    const existingTopics = new Set(
+      existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
+    );
+    const fresh = filterNewDrafts2(drafts, existingTopics);
+    const skipped = drafts.length - fresh.length;
+    if (opts.json) {
+      const created2 = [];
+      if (!opts.dryRun) {
+        for (const draft of fresh) created2.push(await writeDraft2(paths, draft));
+      }
+      console.log(
+        JSON.stringify(
+          {
+            format,
+            parsed: drafts.length,
+            new: fresh.length,
+            skipped_existing: skipped,
+            dry_run: Boolean(opts.dryRun),
+            drafts: fresh.map((d) => ({
+              id: d.frontmatter.id,
+              topic: d.topic,
+              path: d.finding.path,
+              rule: d.finding.ruleId,
+              severity: d.finding.severity,
+              has_sensor: d.has_sensor
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(
+      ui.bold(
+        `hAIve ingest (${format}) \u2014 ${drafts.length} finding(s), ${fresh.length} new` + (skipped > 0 ? `, ${skipped} already ingested` : "")
+      )
+    );
+    if (fresh.length === 0) {
+      ui.info("Nothing to ingest.");
+      return;
+    }
+    for (const draft of fresh) {
+      const sensorTag = draft.has_sensor ? ui.dim(" +sensor") : "";
+      console.log(
+        `  \u2022 ${draft.finding.ruleId} ${ui.dim(`(${draft.finding.severity})`)} \u2192 ${draft.finding.path}${sensorTag}`
+      );
+      if (opts.dryRun) console.log(`     ${ui.dim("would create:")} ${draft.frontmatter.id}`);
+    }
+    if (opts.dryRun) {
+      ui.info(`Dry run \u2014 nothing written. Re-run without --dry-run to create ${fresh.length} proposed memory(ies).`);
+      return;
+    }
+    let created = 0;
+    for (const draft of fresh) {
+      await writeDraft2(paths, draft);
+      created++;
+    }
+    ui.success(`Created ${created} proposed memory(ies) under ${path54.relative(root, paths.memoriesDir)}/`);
+    ui.info("Review with `haive memory pending`; promote sensors with `haive sensors promote <id> --yes`.");
+  });
+}
+async function writeDraft2(paths, draft) {
+  const file = memoryFilePath12(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
+  await mkdir23(path54.dirname(file), { recursive: true });
+  await writeFile37(file, serializeMemory28({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  return file;
+}
+async function fetchSonarIssues(opts) {
+  const baseUrl = (opts.sonarUrl ?? process.env.SONAR_HOST_URL ?? "").trim().replace(/\/+$/, "");
+  const token = (opts.sonarToken ?? process.env.SONAR_TOKEN ?? "").trim();
+  const component = (opts.sonarComponent ?? "").trim();
+  if (!baseUrl) {
+    return { ok: false, error: "--from sonar-api needs --sonar-url (or env SONAR_HOST_URL)." };
+  }
+  if (!token) {
+    return { ok: false, error: "--from sonar-api needs --sonar-token (or env SONAR_TOKEN)." };
+  }
+  if (!component) {
+    return { ok: false, error: "--from sonar-api needs --sonar-component <projectKey>." };
+  }
+  if (typeof fetch !== "function") {
+    return { ok: false, error: "global fetch is unavailable \u2014 Node 18+ is required for --from sonar-api." };
+  }
+  const params = new URLSearchParams({ componentKeys: component, resolved: "false", ps: "500" });
+  if (opts.sonarBranch) params.set("branch", opts.sonarBranch);
+  const url = `${baseUrl}/api/issues/search?${params.toString()}`;
+  try {
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json" }
+    });
+    if (!res.ok) {
+      const hint = res.status === 401 || res.status === 403 ? " (check the token and its permissions)" : "";
+      return { ok: false, error: `SonarQube API returned ${res.status} ${res.statusText}${hint}.` };
+    }
+    const json = await res.text();
+    return { ok: true, json };
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Could not reach SonarQube at ${baseUrl}: ${err instanceof Error ? err.message : String(err)}. File-based ingest (--from sonar) still works.`
+    };
+  }
+}
+
+// src/commands/dashboard.ts
+import { existsSync as existsSync78 } from "fs";
+import "commander";
+import {
+  buildDashboard,
+  findProjectRoot as findProjectRoot55,
+  loadMemoriesFromDir as loadMemoriesFromDir41,
+  loadUsageIndex as loadUsageIndex29,
+  resolveHaivePaths as resolveHaivePaths51
+} from "@hiveai/core";
+function registerDashboard(program2) {
+  program2.command("dashboard").description(
+    "Non-interactive observability snapshot of the memory corpus.\n\n  One-shot rollup an agent or CI can read (unlike `haive tui`, no TTY needed):\n  inventory, impact tiers + top memories, sensors (and which ones fired),\n  health (stale / anchorless / pending / prune candidates), decay, and corpus weight.\n  Use --json to pipe it into other tooling."
+  ).option("--json", "emit the full report as JSON", false).option("--top <n>", "rows per top-list", "10").option("--dormant-days <n>", "dormancy window for impact scoring").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot55(opts.dir);
+    const paths = resolveHaivePaths51(root);
+    if (!existsSync78(paths.haiveDir)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const memories = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
+    const usage = await loadUsageIndex29(paths);
+    const top = Math.max(1, Number.parseInt(opts.top ?? "10", 10) || 10);
+    const dormantDays = opts.dormantDays ? Number.parseInt(opts.dormantDays, 10) : void 0;
+    const report = buildDashboard(memories, usage, {
+      top,
+      ...dormantDays !== void 0 && Number.isFinite(dormantDays) ? { dormantDays } : {}
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    renderDashboard(report);
+  });
+}
+function renderDashboard(r) {
+  const { inventory: inv, impact, sensors, health, decay, corpus } = r;
+  console.log(ui.bold("hAIve dashboard"));
+  console.log(
+    `  ${ui.dim("corpus:")} ${inv.total} policy memor${inv.total === 1 ? "y" : "ies"} (${inv.active} active, ${inv.retired} retired) \xB7 ${inv.session_recaps} recap(s) \xB7 ~${corpus.est_tokens.toLocaleString()} tokens`
+  );
+  console.log(`  ${ui.dim("scopes:")} ${formatCounts(inv.by_scope)}`);
+  console.log(`  ${ui.dim("types: ")} ${formatCounts(inv.by_type)}`);
+  console.log();
+  console.log(ui.bold("Impact"));
+  console.log(
+    `  ${ui.green(`high ${impact.high}`)} \xB7 ${ui.yellow(`medium ${impact.medium}`)} \xB7 low ${impact.low} \xB7 ${ui.dim(`dormant ${impact.dormant}`)} \xB7 ${impact.prune_candidates > 0 ? ui.red(`prune ${impact.prune_candidates}`) : "prune 0"}`
+  );
+  if (impact.top.length > 0) {
+    console.log(ui.dim("  top by demonstrated utility:"));
+    for (const row of impact.top.filter((x) => x.score > 0).slice(0, 8)) {
+      console.log(
+        `    ${tierMark(row.tier)} ${row.score.toFixed(2)}  ${row.id}` + (row.signals.length ? ui.dim(`  [${row.signals.join(", ")}]`) : "")
+      );
+    }
+  }
+  console.log();
+  console.log(ui.bold("Sensors"));
+  console.log(
+    `  ${sensors.total} total \xB7 ${sensors.block} block \xB7 ${sensors.warn} warn \xB7 ${ui.dim(`${sensors.autogen} autogen`)} \xB7 ${sensors.fired > 0 ? ui.green(`${sensors.fired} fired`) : "0 fired"}`
+  );
+  for (const s of sensors.recently_fired.slice(0, 5)) {
+    const marker = s.severity === "block" ? ui.red("\u2717") : ui.yellow("\u26A0");
+    console.log(`    ${marker} ${s.id} ${ui.dim(`last fired ${s.last_fired.slice(0, 10)}`)}`);
+  }
+  console.log();
+  console.log(ui.bold("Health"));
+  console.log(
+    `  stale ${warnNum(health.stale)} \xB7 anchorless ${warnNum(health.anchorless)} \xB7 pending ${health.pending} \xB7 prune candidates ${warnNum(health.prune_candidates)}`
+  );
+  if (health.anchorless > 0) {
+    ui.info("Anchorless validated decisions/gotchas can't detect drift \u2014 add `paths`/`symbols`.");
+  }
+  console.log();
+  console.log(ui.bold(`Decay (>${decay.decay_days}d)`));
+  console.log(`  ${decay.decaying} decaying memor${decay.decaying === 1 ? "y" : "ies"}`);
+  for (const d of decay.top_dormant.slice(0, 5)) {
+    const last = d.last_read_at ? d.last_read_at.slice(0, 10) : "never read";
+    console.log(`    ${ui.dim(String(d.age_days).padStart(4) + "d")}  ${d.id}  ${ui.dim(`(${last})`)}`);
+  }
+  if (health.prune_candidates > 0 || decay.decaying > 0) {
+    console.log();
+    ui.info("Review low-value memories with `haive memory impact` and `haive memory lint`.");
+  }
+}
+function formatCounts(map) {
+  const entries = Object.entries(map).sort((a, b) => b[1] - a[1]);
+  if (entries.length === 0) return "none";
+  return entries.map(([k, v]) => `${k} ${v}`).join(", ");
+}
+function tierMark(tier) {
+  if (tier === "high") return ui.green("\u25CF");
+  if (tier === "medium") return ui.yellow("\u25CF");
+  if (tier === "dormant") return ui.dim("\u25CB");
+  return "\xB7";
+}
+function warnNum(n) {
+  return n > 0 ? ui.yellow(String(n)) : String(n);
+}
+
 // src/index.ts
-var program = new Command56();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.12.4").option("--advanced", "show maintenance and experimental commands in help");
+var program = new Command58();
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.13.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -15722,6 +16476,8 @@ registerEnforce(program);
 registerRun(program);
 registerAgent(program);
 registerSensors(program);
+registerIngest(program);
+registerDashboard(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);