brainfile 0.21.1 → 0.22.0

package/dist/chunk-L4WSDMK3.mjs

@@ -0,0 +1,1973 @@
+import { createRequire as __brainfileCreateRequire } from 'node:module';
+import { fileURLToPath as __brainfileFileURLToPath } from 'node:url';
+import { dirname as __brainfileDirname } from 'node:path';
+const require = __brainfileCreateRequire(import.meta.url);
+const __filename = __brainfileFileURLToPath(import.meta.url);
+const __dirname = __brainfileDirname(__filename);
+import {
+  require_boardFile,
+  require_brief,
+  require_briefState,
+  require_decisionOperations,
+  require_decisions,
+  require_dist,
+  require_docGraph,
+  require_docTypes,
+  require_files,
+  require_frontmatter,
+  require_search,
+  require_taskFile,
+  require_workspace
+} from "./chunk-XFDTTLSW.mjs";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-I5SJHUZK.mjs";
+
+// ../core/dist/memory/sqlite.js
+var require_sqlite = __commonJS({
+  "../core/dist/memory/sqlite.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.indexDisabledByEnv = indexDisabledByEnv;
+    exports.loadSqlite = loadSqlite;
+    exports.sqliteAvailable = sqliteAvailable;
+    exports.setSqliteLoaderForTesting = setSqliteLoaderForTesting;
+    var override;
+    var cached;
+    function indexDisabledByEnv(env = process.env) {
+      const value = (env.BRAINFILE_INDEX ?? "").trim().toLowerCase();
+      return value === "off" || value === "0" || value === "false" || value === "no";
+    }
+    function isSqliteExperimentalWarning(warning, rest) {
+      const message = typeof warning === "string" ? warning : warning?.message;
+      const first = rest[0];
+      const type = typeof first === "string" ? first : first?.type ?? warning?.name;
+      return /sqlite/i.test(String(message ?? "")) && String(type ?? "") === "ExperimentalWarning";
+    }
+    function requireSqlite() {
+      const getBuiltin = process.getBuiltinModule;
+      if (typeof getBuiltin !== "function")
+        return null;
+      const original = process.emitWarning;
+      process.emitWarning = function patched(warning, ...rest) {
+        if (isSqliteExperimentalWarning(warning, rest))
+          return;
+        return original.call(process, warning, ...rest);
+      };
+      try {
+        const mod = getBuiltin.call(process, "node:sqlite");
+        if (!mod || typeof mod.DatabaseSync !== "function")
+          return null;
+        const probe = new mod.DatabaseSync(":memory:");
+        try {
+          probe.exec("CREATE VIRTUAL TABLE probe USING fts5(x)");
+        } finally {
+          probe.close();
+        }
+        return mod;
+      } catch {
+        return null;
+      } finally {
+        process.emitWarning = original;
+      }
+    }
+    function loadSqlite() {
+      if (override)
+        return override();
+      if (indexDisabledByEnv())
+        return null;
+      if (cached === void 0)
+        cached = requireSqlite();
+      return cached;
+    }
+    function sqliteAvailable() {
+      return loadSqlite() !== null;
+    }
+    function setSqliteLoaderForTesting(loader) {
+      override = loader;
+      cached = void 0;
+    }
+  }
+});
+
+// ../core/dist/memory/chunk.js
+var require_chunk = __commonJS({
+  "../core/dist/memory/chunk.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_MAX_CHUNK_CHARS = void 0;
+    exports.chunkText = chunkText;
+    exports.firstHeading = firstHeading;
+    exports.DEFAULT_MAX_CHUNK_CHARS = 3e3;
+    var HEADING = /^(#{1,6})\s+(\S.*?)\s*#*\s*$/;
+    var FENCE = /^\s*(```|~~~)/;
+    function sectionsOf(lines, markdown) {
+      const sections = [];
+      let current = { start: 0, lines: [] };
+      let fence = null;
+      lines.forEach((line, index) => {
+        const fenceMatch = FENCE.exec(line);
+        const heading = markdown && fence === null && !fenceMatch ? HEADING.exec(line) : null;
+        if (fenceMatch) {
+          if (fence === null)
+            fence = fenceMatch[1];
+          else if (fenceMatch[1] === fence)
+            fence = null;
+        }
+        if (heading) {
+          if (current.lines.length > 0)
+            sections.push(current);
+          current = { start: index, lines: [], heading: heading[2] };
+        }
+        current.lines.push(line);
+      });
+      if (current.lines.length > 0)
+        sections.push(current);
+      return sections;
+    }
+    function chunkText(text, options = {}) {
+      const maxChars = options.maxChars && options.maxChars > 0 ? options.maxChars : exports.DEFAULT_MAX_CHUNK_CHARS;
+      const offset = options.lineOffset ?? 0;
+      const normalized = text.replace(/\r\n?/g, "\n");
+      if (!normalized.trim())
+        return [];
+      const lines = normalized.split("\n");
+      if (lines[lines.length - 1] === "")
+        lines.pop();
+      const chunks = [];
+      let buffer = [];
+      let bufferStart = 0;
+      let bufferLength = 0;
+      let bufferHeading;
+      const flush = () => {
+        if (buffer.length === 0)
+          return;
+        let first = 0;
+        let last = buffer.length - 1;
+        while (first <= last && !buffer[first].trim())
+          first++;
+        while (last >= first && !buffer[last].trim())
+          last--;
+        if (first <= last) {
+          chunks.push({
+            text: buffer.slice(first, last + 1).join("\n"),
+            startLine: offset + bufferStart + first + 1,
+            endLine: offset + bufferStart + last + 1,
+            ...bufferHeading ? { heading: bufferHeading } : {}
+          });
+        }
+        buffer = [];
+        bufferLength = 0;
+        bufferHeading = void 0;
+      };
+      const push = (line, index, heading) => {
+        if (buffer.length === 0) {
+          bufferStart = index;
+          bufferHeading = heading;
+        }
+        buffer.push(line);
+        bufferLength += line.length + 1;
+      };
+      for (const section of sectionsOf(lines, options.markdown !== false)) {
+        const size = section.lines.reduce((n, l) => n + l.length + 1, 0);
+        if (buffer.length > 0 && bufferLength + size > maxChars)
+          flush();
+        if (size <= maxChars) {
+          section.lines.forEach((line, i) => push(line, section.start + i, section.heading));
+          continue;
+        }
+        section.lines.forEach((line, i) => {
+          if (buffer.length > 0 && bufferLength + line.length + 1 > maxChars)
+            flush();
+          push(line, section.start + i, section.heading);
+        });
+      }
+      flush();
+      return chunks;
+    }
+    function firstHeading(text) {
+      let fence = false;
+      for (const line of text.split(/\r?\n/)) {
+        if (FENCE.test(line)) {
+          fence = !fence;
+          continue;
+        }
+        if (fence)
+          continue;
+        const match = HEADING.exec(line);
+        if (match)
+          return match[2];
+      }
+      return void 0;
+    }
+  }
+});
+
+// ../core/dist/memory/mine.js
+var require_mine = __commonJS({
+  "../core/dist/memory/mine.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ALWAYS_INCLUDED_ROOT_DOCS = exports.SKIP_DIRS = exports.MAX_DOC_FILES = exports.MAX_FILE_BYTES = void 0;
+    exports.isSupportedTextPath = isSupportedTextPath;
+    exports.isSkippedPath = isSkippedPath;
+    exports.isUnminableRoot = isUnminableRoot;
+    exports.listProjectDocs = listProjectDocs;
+    var child_process_1 = __require("child_process");
+    var fs = __importStar(__require("fs"));
+    var os = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    exports.MAX_FILE_BYTES = 256 * 1024;
+    exports.MAX_DOC_FILES = 5e3;
+    exports.SKIP_DIRS = /* @__PURE__ */ new Set([
+      ".brainfile",
+      ".git",
+      ".hg",
+      ".svn",
+      ".recoil",
+      "node_modules",
+      "vendor",
+      "dist",
+      "build",
+      "out",
+      "target",
+      "coverage",
+      ".next",
+      ".cache",
+      "tmp",
+      "temp"
+    ]);
+    var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".mdown", ".txt", ".text", ".rst", ".adoc", ".asciidoc", ".org"]);
+    var OPERATIONAL_NAMES = /* @__PURE__ */ new Set([
+      "agents",
+      "claude",
+      "readme",
+      "security",
+      "security_contacts",
+      "security_policy",
+      "contributing",
+      "contribute",
+      "developers",
+      "developing",
+      "developer"
+    ]);
+    exports.ALWAYS_INCLUDED_ROOT_DOCS = ["AGENTS.md", "CLAUDE.md"];
+    function isOperationalHiddenDir(rel) {
+      return rel === ".github" || rel === ".well-known" || rel.endsWith("/.well-known");
+    }
+    function isSupportedTextPath(rel) {
+      const base = path2.posix.basename(rel).toLowerCase();
+      const ext = path2.posix.extname(base);
+      if (TEXT_EXTENSIONS.has(ext))
+        return true;
+      return ext === "" && OPERATIONAL_NAMES.has(base);
+    }
+    function isSkippedPath(rel) {
+      const parts = rel.split("/").filter(Boolean);
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isDir = i < parts.length - 1;
+        if (isDir && exports.SKIP_DIRS.has(part))
+          return true;
+        if (part.startsWith(".")) {
+          const prefix = parts.slice(0, i + 1).join("/");
+          if (isDir && isOperationalHiddenDir(prefix))
+            continue;
+          return true;
+        }
+      }
+      return false;
+    }
+    function isUnminableRoot(root) {
+      const resolved = path2.resolve(root);
+      return resolved === path2.parse(resolved).root || resolved === path2.resolve(os.homedir());
+    }
+    function statFile(root, rel) {
+      const abs = path2.join(root, rel);
+      try {
+        const stat = fs.statSync(abs);
+        if (!stat.isFile() || stat.size > exports.MAX_FILE_BYTES)
+          return null;
+        return { rel, abs, size: stat.size, mtimeMs: stat.mtimeMs };
+      } catch {
+        return null;
+      }
+    }
+    function gitListing(root) {
+      const result = (0, child_process_1.spawnSync)("git", ["ls-files", "-co", "--exclude-standard", "-z"], {
+        cwd: root,
+        encoding: "utf-8",
+        maxBuffer: 64 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e4
+      });
+      if (result.status !== 0 || typeof result.stdout !== "string")
+        return null;
+      return result.stdout.split("\0").filter(Boolean);
+    }
+    function walkListing(root, limit) {
+      const out = [];
+      const visit = (dir, rel, depth) => {
+        if (out.length >= limit || depth > 12)
+          return;
+        let entries;
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+          if (out.length >= limit)
+            return;
+          const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            if (exports.SKIP_DIRS.has(entry.name))
+              continue;
+            if (entry.name.startsWith(".") && !isOperationalHiddenDir(childRel))
+              continue;
+            visit(path2.join(dir, entry.name), childRel, depth + 1);
+          } else if (entry.isFile() && isSupportedTextPath(childRel) && !isSkippedPath(childRel)) {
+            out.push(childRel);
+          }
+        }
+      };
+      visit(root, "", 0);
+      return out;
+    }
+    function listProjectDocs(root, options = {}) {
+      const limit = options.maxFiles ?? exports.MAX_DOC_FILES;
+      if (isUnminableRoot(root))
+        return { files: [], via: "none" };
+      try {
+        if (!fs.statSync(root).isDirectory())
+          return { files: [], via: "none" };
+      } catch {
+        return { files: [], via: "none" };
+      }
+      const listed = gitListing(root);
+      const via = listed ? "git" : "walk";
+      const candidates = (listed ?? walkListing(root, limit * 4)).map((rel) => rel.split(path2.sep).join("/")).filter((rel) => isSupportedTextPath(rel) && !isSkippedPath(rel));
+      for (const name of exports.ALWAYS_INCLUDED_ROOT_DOCS) {
+        if (!candidates.includes(name) && fs.existsSync(path2.join(root, name)))
+          candidates.push(name);
+      }
+      const files = [];
+      for (const rel of [...new Set(candidates)].sort()) {
+        if (files.length >= limit)
+          break;
+        const file = statFile(root, rel);
+        if (file)
+          files.push(file);
+      }
+      return { files, via };
+    }
+  }
+});
+
+// ../core/dist/memory/memoryIndex.js
+var require_memoryIndex = __commonJS({
+  "../core/dist/memory/memoryIndex.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MemoryIndex = exports.INDEX_SOURCES = exports.INDEX_FILENAME = exports.INDEX_SCHEMA_VERSION = void 0;
+    exports.getIndexPath = getIndexPath;
+    exports.ftsTerms = ftsTerms;
+    var crypto = __importStar(__require("crypto"));
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var frontmatter_1 = require_frontmatter();
+    var boardFile_1 = require_boardFile();
+    var workspace_1 = require_workspace();
+    var briefState_1 = require_briefState();
+    var files_1 = require_files();
+    var docTypes_1 = require_docTypes();
+    var docGraph_1 = require_docGraph();
+    var search_1 = require_search();
+    var decisions_1 = require_decisions();
+    var chunk_1 = require_chunk();
+    var mine_1 = require_mine();
+    var sqlite_1 = require_sqlite();
+    exports.INDEX_SCHEMA_VERSION = "2";
+    exports.INDEX_FILENAME = "index.db";
+    exports.INDEX_SOURCES = ["board", "logs", "ledger", "plans", "repo"];
+    function getIndexPath(brainfilePath) {
+      return path2.join((0, briefState_1.getBriefStateDir)(brainfilePath), exports.INDEX_FILENAME);
+    }
+    var SCHEMA = `
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS sources (
+  path TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  size INTEGER NOT NULL,
+  mtime_ms REAL NOT NULL,
+  hash TEXT NOT NULL,
+  indexed_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS chunks (
+  id INTEGER PRIMARY KEY,
+  path TEXT NOT NULL,
+  source TEXT NOT NULL,
+  doc_id TEXT,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  ident TEXT NOT NULL,
+  heading TEXT,
+  start_line INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  lane TEXT NOT NULL,
+  type TEXT,
+  role TEXT,
+  status TEXT,
+  column_id TEXT,
+  meta TEXT
+);
+CREATE INDEX IF NOT EXISTS chunks_path ON chunks(path);
+CREATE INDEX IF NOT EXISTS chunks_doc ON chunks(doc_id);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+  title, body, ident,
+  content='chunks', content_rowid='id',
+  tokenize='porter unicode61'
+);
+CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+  INSERT INTO chunks_fts(rowid, title, body, ident) VALUES (new.id, new.title, new.body, new.ident);
+END;
+CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+  INSERT INTO chunks_fts(chunks_fts, rowid, title, body, ident) VALUES ('delete', old.id, old.title, old.body, old.ident);
+END;
+CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+  INSERT INTO chunks_fts(chunks_fts, rowid, title, body, ident) VALUES ('delete', old.id, old.title, old.body, old.ident);
+  INSERT INTO chunks_fts(rowid, title, body, ident) VALUES (new.id, new.title, new.body, new.ident);
+END;
+`;
+    var DROP = `
+DROP TRIGGER IF EXISTS chunks_ai;
+DROP TRIGGER IF EXISTS chunks_ad;
+DROP TRIGGER IF EXISTS chunks_au;
+DROP TABLE IF EXISTS chunks_fts;
+DROP TABLE IF EXISTS chunks;
+DROP TABLE IF EXISTS sources;
+DROP TABLE IF EXISTS meta;
+`;
+    var BM25_WEIGHTS = "4.0, 1.0, 2.0";
+    var MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".mdown", ""]);
+    function sha256(data) {
+      return crypto.createHash("sha256").update(data).digest("hex");
+    }
+    function posixRelative(root, abs) {
+      return path2.relative(root, abs).split(path2.sep).join("/");
+    }
+    function decodeUtf8(data) {
+      if (data.includes(0))
+        return null;
+      try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(data);
+      } catch {
+        return null;
+      }
+    }
+    function listMarkdown(dir, recursive) {
+      const out = [];
+      const visit = (current, depth) => {
+        let entries;
+        try {
+          entries = fs.readdirSync(current, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const entry of entries) {
+          const abs = path2.join(current, entry.name);
+          if (entry.isDirectory()) {
+            if (recursive && depth < 6 && !entry.name.startsWith("."))
+              visit(abs, depth + 1);
+          } else if (entry.isFile() && /\.(md|markdown|txt)$/i.test(entry.name)) {
+            out.push(abs);
+          }
+        }
+      };
+      visit(dir, 0);
+      return out.sort();
+    }
+    function frontmatterLines(text2) {
+      const lines = text2.split("\n");
+      if (lines[0]?.trim() !== "---")
+        return 0;
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trimEnd() === "---")
+          return i + 1 + (lines[i + 1] === "" ? 1 : 0);
+      }
+      return 0;
+    }
+    function ftsTerms(query, ignore) {
+      const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const terms = [];
+      const seen = /* @__PURE__ */ new Set();
+      const keep = (tokens) => {
+        const key = tokens.join(" ");
+        if (!key || seen.has(key) || terms.length >= 32)
+          return;
+        if (tokens.length === 1 && key.length < 2)
+          return;
+        seen.add(key);
+        const last = tokens[tokens.length - 1];
+        terms.push(`"${key}"${tokens.length === 1 || last.length >= 3 ? "*" : ""}`);
+      };
+      const significant = new Set((0, decisions_1.significantTokens)(query, ignore));
+      for (const word of words) {
+        const tokens = word.match(/[a-z0-9_]+/g) ?? [];
+        if (tokens.length === 0)
+          continue;
+        if (tokens.length === 1) {
+          if (significant.has(tokens[0]))
+            keep(tokens);
+          continue;
+        }
+        if (tokens.some((t) => significant.has(t)))
+          keep(tokens);
+      }
+      return terms;
+    }
+    function normalizeRank(rank) {
+      const abs = Math.abs(rank);
+      return abs / (1 + abs);
+    }
+    function pathPrior(source, rel) {
+      if (source !== "repo")
+        return 0;
+      const lower = rel.toLowerCase();
+      const base = path2.posix.basename(lower);
+      const parts = lower.split("/");
+      if (base === "agents.md" || base === "claude.md")
+        return 0.06;
+      if (parts.length === 1 && base.startsWith("readme"))
+        return 0.04;
+      if (base.includes("changelog") || base.includes("release-notes"))
+        return -0.05;
+      if (parts.some((p) => ["fixtures", "fixture", "testdata", "__tests__", "examples", "example", "public", "static"].includes(p)))
+        return -0.1;
+      if (parts.some((p) => p === "docs" || p === "doc"))
+        return 0.02;
+      return 0;
+    }
+    function parseMeta(raw) {
+      if (typeof raw !== "string" || !raw)
+        return {};
+      try {
+        const value = JSON.parse(raw);
+        return value && typeof value === "object" ? value : {};
+      } catch {
+        return {};
+      }
+    }
+    function text(value) {
+      if (value instanceof Date)
+        return value.toISOString();
+      return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    }
+    var MemoryIndex = class _MemoryIndex {
+      constructor(db, dbPath, brainfilePath, projectRoot) {
+        this.statements = /* @__PURE__ */ new Map();
+        this.db = db;
+        this.path = dbPath;
+        this.brainfilePath = brainfilePath;
+        this.projectRoot = projectRoot;
+        this.dirs = (0, workspace_1.getV2Dirs)(brainfilePath);
+      }
+      /**
+       * Open (or create) the index of a board. Null when `node:sqlite` is not
+       * available, the index is turned off, `create: false` and there is none, or
+       * the database cannot be opened even after a rebuild.
+       */
+      static open(brainfilePath, options = {}) {
+        const sqlite = (0, sqlite_1.loadSqlite)();
+        if (!sqlite)
+          return null;
+        const resolved = path2.resolve(brainfilePath);
+        const dbPath = getIndexPath(resolved);
+        const exists = fs.existsSync(dbPath);
+        if (!exists && options.create === false)
+          return null;
+        const projectRoot = path2.resolve(options.projectRoot ?? path2.dirname(path2.dirname(resolved)));
+        const attempt = () => {
+          if (!exists) {
+            (0, files_1.ensureDotBrainfileGitignore)(resolved);
+            fs.mkdirSync(path2.dirname(dbPath), { recursive: true });
+          }
+          const db = new sqlite.DatabaseSync(dbPath);
+          try {
+            db.exec("PRAGMA busy_timeout = 3000");
+            try {
+              db.exec("PRAGMA journal_mode = WAL");
+            } catch {
+            }
+            db.exec("PRAGMA synchronous = NORMAL");
+            const index = new _MemoryIndex(db, dbPath, resolved, projectRoot);
+            index.ensureSchema();
+            return index;
+          } catch (err) {
+            db.close();
+            throw err;
+          }
+        };
+        try {
+          return attempt();
+        } catch {
+          try {
+            for (const suffix of ["", "-wal", "-shm"])
+              fs.rmSync(`${dbPath}${suffix}`, { force: true });
+            return attempt();
+          } catch {
+            return null;
+          }
+        }
+      }
+      close() {
+        this.statements.clear();
+        try {
+          this.db.close();
+        } catch {
+        }
+      }
+      stmt(sql) {
+        let statement = this.statements.get(sql);
+        if (!statement) {
+          statement = this.db.prepare(sql);
+          this.statements.set(sql, statement);
+        }
+        return statement;
+      }
+      getMeta(key) {
+        const row = this.stmt("SELECT value FROM meta WHERE key = ?").get(key);
+        return row ? String(row.value) : void 0;
+      }
+      setMeta(key, value) {
+        this.stmt("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+      }
+      ensureSchema() {
+        let version;
+        try {
+          version = this.getMeta("schema_version");
+        } catch {
+          version = void 0;
+        }
+        if (version === exports.INDEX_SCHEMA_VERSION)
+          return;
+        this.statements.clear();
+        this.db.exec(DROP);
+        this.db.exec(SCHEMA);
+        this.setMeta("schema_version", exports.INDEX_SCHEMA_VERSION);
+      }
+      /** Drop everything and index from scratch. */
+      rebuild() {
+        this.statements.clear();
+        this.db.exec(DROP);
+        this.db.exec(SCHEMA);
+        this.setMeta("schema_version", exports.INDEX_SCHEMA_VERSION);
+        return this.refresh();
+      }
+      boardConfig() {
+        return (0, boardFile_1.readBoardConfig)(this.dirs.brainfilePath)?.config ?? null;
+      }
+      collectFiles() {
+        const files = [];
+        const add = (abs, source) => {
+          try {
+            const stat = fs.statSync(abs);
+            if (!stat.isFile())
+              return;
+            files.push({ path: posixRelative(this.projectRoot, abs), abs, source, size: stat.size, mtimeMs: stat.mtimeMs });
+          } catch {
+          }
+        };
+        for (const abs of listMarkdown(this.dirs.boardDir, false))
+          if (abs.endsWith(".md"))
+            add(abs, "board");
+        for (const abs of listMarkdown(this.dirs.logsDir, false))
+          if (abs.endsWith(".md"))
+            add(abs, "logs");
+        add(path2.join(this.dirs.logsDir, "ledger.jsonl"), "ledger");
+        for (const abs of listMarkdown(path2.join(this.dirs.dotDir, "plans"), true))
+          add(abs, "plans");
+        const mined = (0, mine_1.listProjectDocs)(this.projectRoot);
+        const dotPrefix = posixRelative(this.projectRoot, this.dirs.dotDir);
+        for (const file of mined.files) {
+          if (dotPrefix && (file.rel === dotPrefix || file.rel.startsWith(`${dotPrefix}/`)))
+            continue;
+          files.push({ path: file.rel, abs: file.abs, source: "repo", size: file.size, mtimeMs: file.mtimeMs });
+        }
+        return { files, via: mined.via };
+      }
+      /**
+       * Bring the index up to date with the files: unchanged files (same size and
+       * mtime, or same hash) are left alone, changed ones replace their chunks,
+       * deleted ones drop out. With a `deadline` (epoch ms), files not reached in
+       * time are left for the next refresh. When another process is writing the
+       * index, nothing is done and `busy` is set.
+       */
+      refresh(options = {}) {
+        const started = Date.now();
+        const stats = { added: 0, updated: 0, unchanged: 0, removed: 0, skipped: 0, incomplete: false, busy: false, via: "none", ms: 0 };
+        const config = this.boardConfig();
+        const typesKey = sha256(JSON.stringify(config?.types ?? {}));
+        const typesChanged = this.getMeta("types_key") !== typesKey;
+        const { files, via } = this.collectFiles();
+        stats.via = via;
+        const known = /* @__PURE__ */ new Map();
+        for (const row of this.stmt("SELECT path, source, size, mtime_ms, hash FROM sources").all()) {
+          known.set(String(row.path), { size: Number(row.size), mtime: Number(row.mtime_ms), hash: String(row.hash), source: String(row.source) });
+        }
+        try {
+          this.db.exec("BEGIN IMMEDIATE");
+        } catch {
+          stats.busy = true;
+          stats.ms = Date.now() - started;
+          return stats;
+        }
+        try {
+          const seen = /* @__PURE__ */ new Set();
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          for (const file of files) {
+            if (seen.has(file.path))
+              continue;
+            seen.add(file.path);
+            const prev = known.get(file.path);
+            const forced = typesChanged && (file.source === "board" || file.source === "logs");
+            if (prev && !forced && prev.source === file.source && prev.size === file.size && prev.mtime === file.mtimeMs) {
+              stats.unchanged++;
+              continue;
+            }
+            if (options.deadline !== void 0 && Date.now() > options.deadline) {
+              stats.incomplete = true;
+              stats.skipped++;
+              continue;
+            }
+            let data;
+            try {
+              data = fs.readFileSync(file.abs);
+            } catch {
+              stats.skipped++;
+              continue;
+            }
+            const hash = sha256(data);
+            if (prev && !forced && prev.source === file.source && prev.hash === hash) {
+              this.stmt("UPDATE sources SET size = ?, mtime_ms = ? WHERE path = ?").run(file.size, file.mtimeMs, file.path);
+              stats.unchanged++;
+              continue;
+            }
+            const content = decodeUtf8(data);
+            const rows = content === null ? [] : this.chunksFor(file, content, config?.types);
+            this.stmt("DELETE FROM chunks WHERE path = ?").run(file.path);
+            const insert = this.stmt(`INSERT INTO chunks
+          (path, source, doc_id, title, body, ident, heading, start_line, end_line, lane, type, role, status, column_id, meta)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            for (const row of rows) {
+              insert.run(row.path, row.source, row.docId, row.title, row.body, row.ident, row.heading, row.startLine, row.endLine, row.lane, row.type, row.role, row.status, row.column, row.meta);
+            }
+            this.stmt(`INSERT INTO sources(path, source, size, mtime_ms, hash, indexed_at) VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(path) DO UPDATE SET source = excluded.source, size = excluded.size, mtime_ms = excluded.mtime_ms,
+          hash = excluded.hash, indexed_at = excluded.indexed_at`).run(file.path, file.source, file.size, file.mtimeMs, hash, now);
+            if (prev)
+              stats.updated++;
+            else
+              stats.added++;
+          }
+          for (const key of known.keys()) {
+            if (seen.has(key))
+              continue;
+            this.stmt("DELETE FROM chunks WHERE path = ?").run(key);
+            this.stmt("DELETE FROM sources WHERE path = ?").run(key);
+            stats.removed++;
+          }
+          if (!stats.incomplete)
+            this.setMeta("types_key", typesKey);
+          this.setMeta("last_refresh", now);
+          this.db.exec("COMMIT");
+        } catch (err) {
+          try {
+            this.db.exec("ROLLBACK");
+          } catch {
+          }
+          throw err;
+        }
+        stats.ms = Date.now() - started;
+        return stats;
+      }
+      chunksFor(file, content, types) {
+        if (file.source === "ledger")
+          return this.ledgerChunks(file, content);
+        if (file.source === "board" || file.source === "logs") {
+          const rows = this.boardChunks(file, content, types);
+          if (rows)
+            return rows;
+        }
+        return this.fileChunks(file, content);
+      }
+      boardChunks(file, content, types) {
+        const parsed = (0, frontmatter_1.parseFrontmatter)(content);
+        if (!parsed || !parsed.data || typeof parsed.data.id !== "string" || typeof parsed.data.title !== "string")
+          return null;
+        const task = parsed.data;
+        const resolved = (0, docTypes_1.resolveDocType)(task.type, types);
+        const isDecision = resolved.role === "decision";
+        const status = isDecision ? (0, docGraph_1.decisionStatus)(task) : file.source === "logs" || task.completedAt ? "completed" : "open";
+        const lane = isDecision ? (0, decisions_1.isHistoricalStatus)(status) ? "history" : "current" : status === "completed" ? "history" : "current";
+        const record = task;
+        const claimKey = (0, decisions_1.claimKeyOf)(task);
+        const tags = Array.isArray(task.tags) ? task.tags.filter((t) => typeof t === "string") : [];
+        const ident = [
+          claimKey ? claimKey.replace(/[.-]/g, " ") : "",
+          ...tags,
+          text(record.subject) ?? "",
+          text(record.kind) ?? "",
+          text(record.stance) ?? ""
+        ].filter(Boolean).join(" ");
+        const meta = JSON.stringify({
+          ...task.priority ? { priority: task.priority } : {},
+          ...tags.length ? { tags } : {},
+          ...text(task.assignee) ? { assignee: text(task.assignee) } : {},
+          ...text(task.dueDate) ? { dueDate: text(task.dueDate) } : {},
+          ...task.contract?.status ? { contract: task.contract.status } : {},
+          ...text(task.completedAt) ? { completedAt: text(task.completedAt) } : {},
+          ...claimKey ? { claimKey } : {},
+          ...text(task.parentId) ? { parentId: text(task.parentId) } : {},
+          ...text(record.supersededBy) ? { supersededBy: text(record.supersededBy) } : {}
+        });
+        const description = text(task.description);
+        const offset = frontmatterLines(content);
+        const chunks = (0, chunk_1.chunkText)(parsed.body, { lineOffset: offset });
+        if (chunks.length === 0)
+          chunks.push({ text: "", startLine: 1, endLine: Math.max(1, offset) });
+        if (description)
+          chunks[0] = { ...chunks[0], text: `${description}
+
+${chunks[0].text}`.trim() };
+        return chunks.map((chunk) => ({
+          path: file.path,
+          source: file.source,
+          docId: task.id,
+          title: task.title,
+          body: chunk.text,
+          ident,
+          heading: chunk.heading ?? null,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          lane,
+          type: resolved.name === "task" ? null : resolved.name,
+          role: resolved.role,
+          status,
+          column: isDecision || file.source === "logs" ? null : text(task.column) ?? null,
+          meta
+        }));
+      }
+      ledgerChunks(file, content) {
+        const rows = [];
+        content.split("\n").forEach((line, index) => {
+          if (!line.trim())
+            return;
+          let record;
+          try {
+            record = JSON.parse(line);
+          } catch {
+            return;
+          }
+          if (!record || typeof record.id !== "string")
+            return;
+          const files = Array.isArray(record.filesChanged) ? record.filesChanged.join(" ") : "";
+          const tags = Array.isArray(record.tags) ? record.tags.filter((t) => typeof t === "string") : [];
+          rows.push({
+            path: file.path,
+            source: "ledger",
+            docId: record.id,
+            title: typeof record.title === "string" ? record.title : record.id,
+            body: [typeof record.summary === "string" ? record.summary : "", files ? `Files: ${files}` : ""].filter(Boolean).join("\n"),
+            ident: tags.join(" "),
+            heading: null,
+            startLine: index + 1,
+            endLine: index + 1,
+            lane: "history",
+            type: typeof record.type === "string" && record.type !== "task" ? record.type : null,
+            role: record.type === "adr" ? "decision" : "task",
+            status: "completed",
+            column: null,
+            meta: JSON.stringify({
+              ...record.priority ? { priority: record.priority } : {},
+              ...tags.length ? { tags } : {},
+              ...text(record.assignee) ? { assignee: text(record.assignee) } : {},
+              ...text(record.completedAt) ? { completedAt: text(record.completedAt) } : {},
+              ...record.contractStatus ? { contract: record.contractStatus } : {}
+            })
+          });
+        });
+        return rows;
+      }
+      fileChunks(file, content) {
+        const ext = path2.posix.extname(file.path).toLowerCase();
+        const markdown = MARKDOWN_EXTENSIONS.has(ext);
+        const docTitle = (markdown ? (0, chunk_1.firstHeading)(content) : void 0) ?? path2.posix.basename(file.path);
+        return (0, chunk_1.chunkText)(content, { markdown }).map((chunk) => ({
+          path: file.path,
+          source: file.source,
+          docId: null,
+          title: chunk.heading && chunk.heading !== docTitle ? `${docTitle} \u203A ${chunk.heading}` : docTitle,
+          body: chunk.text,
+          ident: file.path.replace(/[/._-]+/g, " "),
+          heading: chunk.heading ?? null,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          lane: "current",
+          type: null,
+          role: null,
+          status: null,
+          column: null,
+          meta: null
+        }));
+      }
+      /** Counts by source, size on disk and the last refresh. */
+      status() {
+        const empty = () => ({ board: 0, logs: 0, ledger: 0, plans: 0, repo: 0 });
+        const files = empty();
+        const chunks = empty();
+        for (const row of this.stmt("SELECT source, COUNT(*) AS n FROM sources GROUP BY source").all()) {
+          files[String(row.source)] = Number(row.n);
+        }
+        for (const row of this.stmt("SELECT source, COUNT(*) AS n FROM chunks GROUP BY source").all()) {
+          chunks[String(row.source)] = Number(row.n);
+        }
+        let sizeBytes = 0;
+        for (const suffix of ["", "-wal"]) {
+          try {
+            sizeBytes += fs.statSync(`${this.path}${suffix}`).size;
+          } catch {
+          }
+        }
+        const lastRefresh = this.getMeta("last_refresh");
+        return {
+          path: this.path,
+          projectRoot: this.projectRoot,
+          schemaVersion: exports.INDEX_SCHEMA_VERSION,
+          sizeBytes,
+          ...lastRefresh ? { lastRefresh } : {},
+          files,
+          chunks,
+          totalFiles: Object.values(files).reduce((a, b) => a + b, 0),
+          totalChunks: Object.values(chunks).reduce((a, b) => a + b, 0)
+        };
+      }
+      /**
+       * Search the index. Null when the query has no words to search on (a
+       * filter-only query such as `p:high`): the caller falls back to the scan.
+       */
+      search(query, options = {}) {
+        const limit = options.limit && options.limit > 0 ? options.limit : 20;
+        const parsed = (0, search_1.parseSearchQuery)(query);
+        const filters = {};
+        for (const [key, value] of Object.entries({ ...parsed, ...definedOnly(options.filters) })) {
+          if (key !== "text" && value !== void 0 && value !== "")
+            filters[key] = value;
+        }
+        const terms = ftsTerms(parsed.text, options.ignoreWords);
+        if (terms.length === 0)
+          return null;
+        const exactId = parsed.text.trim();
+        const structural = Object.keys(filters).length > 0;
+        let sources = (options.sources ?? exports.INDEX_SOURCES).filter((s) => exports.INDEX_SOURCES.includes(s));
+        if (structural)
+          sources = sources.filter((s) => s === "board" || s === "logs" || s === "ledger");
+        if (filters.column)
+          sources = sources.filter((s) => s === "board");
+        if (sources.length === 0)
+          return { current: [], history: [] };
+        const where = [`chunks.source IN (${sources.map(() => "?").join(", ")})`];
+        const params = [...sources];
+        if (options.role === "decision")
+          where.push(`chunks.role = 'decision'`);
+        if (options.role === "work")
+          where.push(`(chunks.role IS NULL OR chunks.role != 'decision')`);
+        const sql = `SELECT chunks.*, bm25(chunks_fts, ${BM25_WEIGHTS}) AS rank,
+        snippet(chunks_fts, 1, '', '', '\u2026', 16) AS snippet
+      FROM chunks_fts JOIN chunks ON chunks.id = chunks_fts.rowid
+      WHERE chunks_fts MATCH ? AND ${where.join(" AND ")}
+      ORDER BY rank LIMIT ?`;
+        const sqlLimit = Math.max(limit * 6, 60);
+        const best = /* @__PURE__ */ new Map();
+        const coverageTokens = options.minCoverage ? (0, decisions_1.significantTokens)(parsed.text, options.ignoreWords) : [];
+        const consider = (row, strict) => {
+          if (!strict && options.minCoverage && (0, decisions_1.tokenCoverage)(coverageTokens, `${row.title}
+${row.body}
+${row.ident}`) < options.minCoverage)
+            return;
+          const hit = this.hitFromRow(row);
+          if (structural && !this.rowMatchesFilters(hit, row, filters))
+            return;
+          hit.score = normalizeRank(Number(row.rank)) + (strict ? 1 : 0) + pathPrior(hit.source, hit.path) + (hit.role === "decision" && hit.lane === "current" ? 0.05 : 0) + (exactId && hit.id.toLowerCase() === exactId ? 10 : 0);
+          hit.score = Math.round(hit.score * 1e4) / 1e4;
+          const key = hit.source === "board" || hit.source === "logs" || hit.source === "ledger" ? `doc:${hit.id}` : `file:${hit.path}`;
+          const existing = best.get(key);
+          if (!existing || existing.source === "ledger" && hit.source !== "ledger" || hit.score > existing.score && !(hit.source === "ledger" && existing.source !== "ledger")) {
+            best.set(key, hit);
+          }
+        };
+        const run = (match, strict) => {
+          for (const row of this.stmt(sql).all(match, ...params, sqlLimit))
+            consider(row, strict);
+        };
+        run(terms.join(" AND "), true);
+        if (best.size < limit && terms.length > 1)
+          run(terms.join(" OR "), false);
+        if (exactId && /^[a-z0-9][\w-]*-\d+$/i.test(exactId) && !best.has(`doc:${exactId}`)) {
+          const row = this.db.prepare(`SELECT chunks.*, 0 AS rank, NULL AS snippet FROM chunks
+        WHERE doc_id = ? AND source IN (${sources.map(() => "?").join(", ")}) ORDER BY start_line LIMIT 1`).get(exactId, ...sources);
+          if (row)
+            consider(row, true);
+        }
+        const hits = [...best.values()].sort((a, b) => b.score - a.score);
+        return {
+          current: hits.filter((h) => h.lane === "current").slice(0, limit),
+          history: hits.filter((h) => h.lane === "history").slice(0, limit)
+        };
+      }
+      hitFromRow(row) {
+        const meta = parseMeta(row.meta);
+        const source = String(row.source);
+        const rel = String(row.path);
+        const start = Number(row.start_line);
+        const end = Number(row.end_line);
+        const docId = typeof row.doc_id === "string" && row.doc_id ? row.doc_id : null;
+        const snippet = typeof row.snippet === "string" && row.snippet.trim() ? row.snippet.replace(/\s+/g, " ").trim() : void 0;
+        return {
+          id: docId ?? `${rel}:${start}-${end}`,
+          title: String(row.title),
+          source,
+          lane: String(row.lane) === "history" ? "history" : "current",
+          path: rel,
+          startLine: start,
+          endLine: end,
+          score: 0,
+          ...snippet ? { snippet } : {},
+          ...typeof row.type === "string" && row.type ? { type: row.type } : {},
+          ...typeof row.role === "string" && row.role ? { role: row.role } : {},
+          ...typeof row.status === "string" && row.status ? { status: row.status } : {},
+          ...typeof row.column_id === "string" && row.column_id ? { column: row.column_id } : {},
+          ...typeof meta.completedAt === "string" ? { completedAt: meta.completedAt } : {},
+          ...typeof meta.claimKey === "string" ? { claimKey: meta.claimKey } : {},
+          ...typeof meta.priority === "string" ? { priority: meta.priority } : {},
+          ...Array.isArray(meta.tags) ? { tags: meta.tags } : {},
+          ...typeof meta.assignee === "string" ? { assignee: meta.assignee } : {},
+          isLog: source === "logs" || source === "ledger"
+        };
+      }
+      rowMatchesFilters(hit, row, filters) {
+        if (hit.source === "repo" || hit.source === "plans")
+          return false;
+        const meta = parseMeta(row.meta);
+        const pseudo = {
+          id: hit.id,
+          title: hit.title,
+          ...hit.type ? { type: hit.type } : {},
+          ...hit.column ? { column: hit.column } : {},
+          ...hit.priority ? { priority: hit.priority } : {},
+          ...hit.tags ? { tags: hit.tags } : {},
+          ...hit.assignee ? { assignee: hit.assignee } : {},
+          ...typeof meta.dueDate === "string" ? { dueDate: meta.dueDate } : {},
+          ...typeof meta.contract === "string" ? { contract: { status: meta.contract } } : {}
+        };
+        return (0, search_1.taskMatchesFilters)(pseudo, filters);
+      }
+      /**
+       * Documents that share a text's most distinctive words: the query's terms
+       * that occur in `sources`, rarest first; the three rarest ANDed, then two,
+       * then one, until something matches. How the brief finds the docs that
+       * bear on a task from its title, where an OR over every word would match
+       * anything that says "board".
+       */
+      relatedDocs(text2, options = {}) {
+        const limit = options.limit ?? 2;
+        const sources = (options.sources ?? ["repo", "plans"]).filter((s) => exports.INDEX_SOURCES.includes(s));
+        if (sources.length === 0)
+          return [];
+        const placeholders = sources.map(() => "?").join(", ");
+        const countSql = `SELECT count(*) AS n FROM chunks_fts JOIN chunks ON chunks.id = chunks_fts.rowid
+      WHERE chunks_fts MATCH ? AND chunks.source IN (${placeholders})`;
+        const ranked = ftsTerms(text2).map((term) => ({ term, n: Number(this.stmt(countSql).get(term, ...sources)?.n ?? 0) })).filter((t) => t.n > 0).sort((a, b) => a.n - b.n);
+        const sql = `SELECT chunks.*, bm25(chunks_fts, ${BM25_WEIGHTS}) AS rank,
+        snippet(chunks_fts, 1, '', '', '\u2026', 16) AS snippet
+      FROM chunks_fts JOIN chunks ON chunks.id = chunks_fts.rowid
+      WHERE chunks_fts MATCH ? AND chunks.source IN (${placeholders})
+      ORDER BY rank LIMIT ?`;
+        for (let k = Math.min(3, ranked.length); k >= 1; k--) {
+          const match = ranked.slice(0, k).map((t) => t.term).join(" AND ");
+          const best = /* @__PURE__ */ new Map();
+          for (const row of this.stmt(sql).all(match, ...sources, limit * 4)) {
+            const hit = this.hitFromRow(row);
+            hit.score = Math.round((normalizeRank(Number(row.rank)) + k + pathPrior(hit.source, hit.path)) * 1e4) / 1e4;
+            const existing = best.get(hit.path);
+            if (!existing || hit.score > existing.score)
+              best.set(hit.path, hit);
+          }
+          if (best.size > 0)
+            return [...best.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+        }
+        return [];
+      }
+      /** The decisions whose words best match a text, best first (any status): how `check` finds a claim family. */
+      decisionCandidates(query, options = {}) {
+        const result = this.search(query, {
+          limit: options.limit ?? 8,
+          sources: ["board", "logs"],
+          role: "decision",
+          ...options.ignoreWords ? { ignoreWords: options.ignoreWords } : {}
+        });
+        if (!result)
+          return [];
+        return [...result.current, ...result.history].sort((a, b) => b.score - a.score).map((hit) => hit.id);
+      }
+    };
+    exports.MemoryIndex = MemoryIndex;
+    function definedOnly(value) {
+      const out = {};
+      for (const [key, v] of Object.entries(value ?? {})) {
+        if (v !== void 0)
+          out[key] = v;
+      }
+      return out;
+    }
+  }
+});
+
+// ../core/dist/memory/search.js
+var require_search2 = __commonJS({
+  "../core/dist/memory/search.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hitFromDocument = hitFromDocument;
+    exports.scanSearch = scanSearch;
+    exports.searchMemory = searchMemory;
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var boardFile_1 = require_boardFile();
+    var taskFile_1 = require_taskFile();
+    var workspace_1 = require_workspace();
+    var docTypes_1 = require_docTypes();
+    var docGraph_1 = require_docGraph();
+    var decisions_1 = require_decisions();
+    var search_1 = require_search();
+    var memoryIndex_1 = require_memoryIndex();
+    function lineCount(filePath) {
+      if (!filePath)
+        return 1;
+      try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        return Math.max(1, lines[lines.length - 1] === "" ? lines.length - 1 : lines.length);
+      } catch {
+        return 1;
+      }
+    }
+    function hitFromDocument(doc, source, score, projectRoot, types) {
+      const task = doc.task;
+      const resolved = (0, docTypes_1.resolveDocType)(task.type, types);
+      const isDecision = resolved.role === "decision";
+      const status = isDecision ? (0, docGraph_1.decisionStatus)(task) : source === "logs" || task.completedAt ? "completed" : "open";
+      const lane = isDecision ? (0, decisions_1.isHistoricalStatus)(status) ? "history" : "current" : status === "completed" ? "history" : "current";
+      const rel = doc.filePath ? path2.relative(projectRoot, doc.filePath).split(path2.sep).join("/") : `${source}/${doc.task.id}.md`;
+      const claimKey = typeof task.claimKey === "string" && task.claimKey.trim() ? task.claimKey.trim().toLowerCase() : void 0;
+      return {
+        id: task.id,
+        title: task.title,
+        source,
+        lane,
+        path: rel,
+        startLine: 1,
+        endLine: lineCount(doc.filePath),
+        score,
+        ...resolved.name !== "task" ? { type: resolved.name } : {},
+        role: resolved.role,
+        status,
+        ...!isDecision && source === "board" && task.column ? { column: task.column } : {},
+        ...typeof task.completedAt === "string" ? { completedAt: task.completedAt } : {},
+        ...claimKey ? { claimKey } : {},
+        ...task.priority ? { priority: task.priority } : {},
+        ...Array.isArray(task.tags) && task.tags.length ? { tags: task.tags } : {},
+        ...typeof task.assignee === "string" && task.assignee ? { assignee: task.assignee } : {},
+        isLog: source === "logs"
+      };
+    }
+    function scanSearch(brainfilePath, query, options = {}) {
+      const dirs = (0, workspace_1.getV2Dirs)(brainfilePath);
+      const projectRoot = path2.dirname(dirs.dotDir);
+      const types = (0, boardFile_1.readBoardConfig)(dirs.brainfilePath)?.config.types;
+      const limit = options.limit && options.limit > 0 ? options.limit : 20;
+      const filters = options.filters ?? {};
+      const wants = (source) => !options.sources || options.sources.includes(source);
+      const hits = [];
+      if (wants("board")) {
+        for (const { doc, score } of (0, search_1.searchTasksRanked)((0, taskFile_1.readTasksDir)(dirs.boardDir), query, filters)) {
+          hits.push(hitFromDocument(doc, "board", score, projectRoot, types));
+        }
+      }
+      if (wants("logs") && !filters.column) {
+        const { column: _column, ...rest } = filters;
+        for (const { doc, score } of (0, search_1.searchTasksRanked)((0, taskFile_1.readTasksDir)(dirs.logsDir), query, rest)) {
+          hits.push(hitFromDocument(doc, "logs", score, projectRoot, types));
+        }
+      }
+      const sorted = hits.map((hit, order) => ({ hit, order })).sort((a, b) => b.hit.score - a.hit.score || a.order - b.order).map(({ hit }) => hit);
+      const current = sorted.filter((h) => h.lane === "current").slice(0, limit);
+      const history = sorted.filter((h) => h.lane === "history").slice(0, limit);
+      const results = [...current, ...history];
+      return { mode: "scan", query, current, history, results, count: results.length };
+    }
+    function searchMemory(brainfilePath, query, options = {}) {
+      if (!options.scan) {
+        const index = memoryIndex_1.MemoryIndex.open(brainfilePath);
+        if (index) {
+          try {
+            const refresh = options.refresh === false ? void 0 : index.refresh();
+            const found = index.search(query, options);
+            if (found) {
+              const results = [...found.current, ...found.history];
+              return {
+                mode: "index",
+                query,
+                current: found.current,
+                history: found.history,
+                results,
+                count: results.length,
+                ...refresh ? { refresh } : {}
+              };
+            }
+          } catch {
+          } finally {
+            index.close();
+          }
+        }
+      }
+      return scanSearch(brainfilePath, query, options);
+    }
+  }
+});
+
+// ../core/dist/memory/brief.js
+var require_brief2 = __commonJS({
+  "../core/dist/memory/brief.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_BRIEF_MAX_CHARS = void 0;
+    exports.composeBrief = composeBrief2;
+    exports.briefItemLine = briefItemLine;
+    exports.renderBriefText = renderBriefText;
+    var path2 = __importStar(__require("path"));
+    var brief_1 = require_brief();
+    var boardFile_1 = require_boardFile();
+    var taskFile_1 = require_taskFile();
+    var docTypes_1 = require_docTypes();
+    var docGraph_1 = require_docGraph();
+    var decisions_1 = require_decisions();
+    var decisionOperations_1 = require_decisionOperations();
+    var memoryIndex_1 = require_memoryIndex();
+    exports.DEFAULT_BRIEF_MAX_CHARS = 1600;
+    var MAX_LINE = 180;
+    function parseMs(value) {
+      if (typeof value !== "string")
+        return null;
+      const ms = Date.parse(value);
+      return Number.isNaN(ms) ? null : ms;
+    }
+    function isAssignedTo(task, agent) {
+      return typeof task.assignee === "string" && task.assignee.trim().toLowerCase() === agent.trim().toLowerCase();
+    }
+    var PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+    var IN_FLIGHT = /progress|doing|review|active|wip|working/i;
+    function workWhy(task, config) {
+      const column = config?.columns?.find((c) => c.id === task.column);
+      const parts = [column?.title ?? task.column ?? ""];
+      if (task.priority)
+        parts.push(task.priority);
+      if (task.contract?.status)
+        parts.push(`contract:${task.contract.status}`);
+      return parts.filter(Boolean).join(" \xB7 ");
+    }
+    function sortWork(tasks, config) {
+      const order = (config?.columns ?? []).map((c) => c.id);
+      const rank = (t) => {
+        const i = order.indexOf(t.column ?? "");
+        return i === -1 ? -1 : i;
+      };
+      return [...tasks].sort((a, b) => rank(b) - rank(a) || (PRIORITY_RANK[a.priority ?? ""] ?? 4) - (PRIORITY_RANK[b.priority ?? ""] ?? 4) || (parseMs(b.updatedAt ?? b.createdAt) ?? 0) - (parseMs(a.updatedAt ?? a.createdAt) ?? 0));
+    }
+    function inFlight(work, config) {
+      const columns = config?.columns ?? [];
+      let ids = columns.filter((c) => IN_FLIGHT.test(c.id) || IN_FLIGHT.test(c.title ?? "")).map((c) => c.id);
+      if (ids.length === 0)
+        ids = columns.slice(1).map((c) => c.id);
+      return work.filter((t) => ids.includes(t.column ?? ""));
+    }
+    function decisionWhy(task) {
+      const record = task;
+      const parts = [];
+      if (typeof record.kind === "string" && record.kind !== "decision")
+        parts.push(record.kind);
+      if (typeof record.stance === "string" && typeof record.subject === "string")
+        parts.push(`${record.stance} ${record.subject}`);
+      if (typeof record.holdsWhile === "string" && record.holdsWhile.trim())
+        parts.push(`while ${record.holdsWhile.trim()}`);
+      if ((task.type ?? "").toLowerCase() === "adr")
+        parts.push("adr");
+      return parts.join(" \xB7 ");
+    }
+    function agoPhrase(from, to) {
+      const rel = (0, brief_1.relativeTime)(from, to);
+      return rel === "just now" || rel === "unknown" ? rel : `${rel} ago`;
+    }
+    function composeBrief2(dirs, agent, options) {
+      const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+      const maxChars = options.maxChars === void 0 ? exports.DEFAULT_BRIEF_MAX_CHARS : Math.max(0, Math.floor(options.maxChars));
+      const base = (0, brief_1.buildBrief)(dirs, agent, { lastBriefAt: options.lastBriefAt, now });
+      const config = (0, boardFile_1.readBoardConfig)(dirs.brainfilePath)?.config ?? null;
+      const types = config?.types;
+      const projectRoot = path2.dirname(dirs.dotDir);
+      const boardDocs = (0, taskFile_1.readTasksDir)(dirs.boardDir);
+      const logDocs = (0, taskFile_1.readTasksDir)(dirs.logsDir);
+      const graph = (0, docGraph_1.buildDocGraph)([...boardDocs.map((d) => d.task), ...logDocs.map((d) => d.task)], { types });
+      const isWork = (task) => (0, docTypes_1.resolveDocType)(task.type, types).role !== "decision";
+      const openWork = boardDocs.map((d) => d.task).filter((t) => isWork(t) && !t.completedAt);
+      const decisions = [...boardDocs, ...logDocs].filter((d) => (0, decisions_1.isDecisionDoc)(d.task, types));
+      const current = decisions.filter((d) => (0, docGraph_1.decisionStatus)(d.task) === "current").sort((a, b) => ((0, decisions_1.claimKeyOf)(a.task) ?? `~${a.task.id}`).localeCompare((0, decisions_1.claimKeyOf)(b.task) ?? `~${b.task.id}`, void 0, { numeric: true }));
+      const mine = sortWork(openWork.filter((t) => isAssignedTo(t, agent)), config);
+      const taskList = mine.length > 0 ? mine : sortWork(inFlight(openWork, config), config);
+      const tasksLane = {
+        id: "tasks",
+        label: mine.length > 0 ? "Your tasks" : "In flight",
+        items: taskList.map((task) => ({ taskId: task.id, text: task.title, why: workWhy(task, config), ...task.updatedAt ? { at: task.updatedAt } : {} }))
+      };
+      const warnings = [];
+      const resting = graph.openWorkOnSupersededDecisions();
+      resting.sort((a, b) => Number(isAssignedTo(b.task, agent)) - Number(isAssignedTo(a.task, agent)));
+      for (const { task, decisions: links } of resting) {
+        const named = links.map((l) => l.supersededBy ? `${l.id} (now ${l.supersededBy})` : l.id).join(", ");
+        warnings.push({ taskId: task.id, text: `${task.title}: rests on superseded ${named}`, why: "rests on a superseded decision" });
+      }
+      const nowMs = parseMs(now) ?? Date.now();
+      for (const doc of current) {
+        const report = (0, decisionOperations_1.evaluateDecisionPredicates)(doc.task, { projectRoot, now: nowMs });
+        if (report.status !== "broken")
+          continue;
+        const broken = report.checks.find((c) => c.status === "broken");
+        const recheck = typeof doc.task.recheck === "string" && doc.task.recheck.trim() ? ` \xB7 recheck: ${doc.task.recheck.trim()}` : "";
+        warnings.push({ taskId: doc.task.id, text: `${doc.task.title}: ${(broken?.reason ?? "predicate broken").replace(/_/g, " ")}${recheck}`, why: "decision needs a look" });
+      }
+      const decisionsLane = {
+        id: "decisions",
+        label: "Current decisions",
+        items: current.map((doc) => {
+          const key = (0, decisions_1.claimKeyOf)(doc.task);
+          return { taskId: doc.task.id, text: key ? `${key}: ${doc.task.title}` : doc.task.title, why: decisionWhy(doc.task) };
+        })
+      };
+      const changes = [];
+      const laneItems = (id) => base.lanes.find((l) => l.id === id)?.items ?? [];
+      if (base.mode === "delta") {
+        const since = parseMs(base.lastBriefAt) ?? 0;
+        for (const doc of decisions) {
+          const created = parseMs(doc.task.createdAt);
+          const updated = parseMs(doc.task.updatedAt);
+          const status = (0, docGraph_1.decisionStatus)(doc.task);
+          if (status === "current" && created !== null && created > since) {
+            const supersedes = doc.task.supersedes ? ` (supersedes ${[doc.task.supersedes].flat().join(", ")})` : "";
+            changes.push({ taskId: doc.task.id, text: `decided: ${doc.task.title}${supersedes}`, why: agoPhrase(doc.task.createdAt, now), at: doc.task.createdAt });
+          } else if (status !== "current" && updated !== null && updated > since) {
+            const by = typeof doc.task.supersededBy === "string" ? ` by ${doc.task.supersededBy}` : "";
+            changes.push({ taskId: doc.task.id, text: `${status}${by}: ${doc.task.title}`, why: agoPhrase(doc.task.updatedAt, now), at: doc.task.updatedAt });
+          }
+        }
+        for (const item of laneItems("notes"))
+          changes.push({ ...item, text: `note: ${item.text}` });
+        for (const item of laneItems("changes"))
+          changes.push(item);
+        for (const item of laneItems("completions"))
+          changes.push({ ...item, text: `completed: ${item.text}` });
+        for (const item of laneItems("config"))
+          changes.push(item);
+        if (changes.length === 0)
+          changes.push({ text: "Nothing new since your last brief.", why: "" });
+      } else {
+        for (const item of laneItems("notes"))
+          changes.push({ ...item, text: `note: ${item.text}` });
+        for (const item of laneItems("completions"))
+          changes.push({ ...item, text: `completed: ${item.text}` });
+      }
+      changes.sort((a, b) => (parseMs(b.at) ?? 0) - (parseMs(a.at) ?? 0));
+      const changesLane = {
+        id: "changes",
+        label: base.mode === "delta" ? "Since your last brief" : "Lately",
+        items: changes
+      };
+      let docsMode = "none";
+      const docItems = [];
+      if (options.docs !== false && taskList.length > 0) {
+        const index = memoryIndex_1.MemoryIndex.open(dirs.brainfilePath);
+        if (index) {
+          try {
+            const budget2 = options.refreshBudgetMs;
+            index.refresh(budget2 === void 0 ? {} : { deadline: Date.now() + budget2 });
+            const best = /* @__PURE__ */ new Map();
+            for (const task of taskList.slice(0, 5)) {
+              for (const hit of index.relatedDocs(task.title, { limit: 2, sources: ["repo", "plans"] })) {
+                const existing = best.get(hit.path);
+                if (!existing || hit.score > existing.score)
+                  best.set(hit.path, hit);
+              }
+            }
+            for (const hit of [...best.values()].sort((a, b) => b.score - a.score).slice(0, 4)) {
+              docItems.push({ text: hit.title, why: `${hit.path}:${hit.startLine}-${hit.endLine}` });
+            }
+            docsMode = "index";
+          } catch {
+          } finally {
+            index.close();
+          }
+        }
+      }
+      const sections = [
+        { id: "warnings", label: "Heads up", items: warnings },
+        decisionsLane,
+        tasksLane,
+        changesLane,
+        { id: "docs", label: "Docs that bear on them", items: docItems }
+      ];
+      const title = config?.title ? ` \xB7 ${config.title}` : "";
+      const when = base.mode === "full" ? "first brief" : `since ${agoPhrase(base.lastBriefAt, now)}`;
+      const header = `Brainfile brief for ${agent}${title} (${when})`;
+      const rendered = renderBriefText(header, sections, maxChars, agent);
+      return { ...base, sections, text: rendered.text, maxChars, truncated: rendered.truncated, docsMode };
+    }
+    function clip(line, max) {
+      if (line.length <= max)
+        return line;
+      return `${line.slice(0, Math.max(1, max - 1)).trimEnd()}\u2026`;
+    }
+    function briefItemLine(laneId, item) {
+      const id = item.taskId ? `${item.taskId} ` : "";
+      switch (laneId) {
+        case "warnings":
+          return `! ${id}${item.text}`;
+        case "docs":
+          return `- ${item.why} ${item.text}`;
+        case "tasks":
+          return `- ${id}${item.text}${item.why ? ` \xB7 ${item.why}` : ""}`;
+        default:
+          return `- ${id}${item.text}${item.why ? ` (${item.why})` : ""}`;
+      }
+    }
+    function renderBriefText(header, sections, maxChars, agent = "") {
+      const lanes = sections.filter((lane) => lane.items.length > 0);
+      if (lanes.length === 0) {
+        const text2 = `${header}
+Nothing on the board for you yet.`;
+        return maxChars > 0 && text2.length > maxChars ? { text: clip(text2, maxChars), truncated: true } : { text: text2, truncated: false };
+      }
+      const lineMax = maxChars > 0 ? Math.min(MAX_LINE, Math.max(40, maxChars)) : MAX_LINE;
+      const heading = (lane) => lane.id === "warnings" ? "" : `## ${lane.label}`;
+      const lines = lanes.map((lane) => lane.items.map((item) => clip(briefItemLine(lane.id, item), lineMax)));
+      const render = (counts2) => {
+        const out = [header];
+        lanes.forEach((lane, i) => {
+          if (counts2[i] === 0)
+            return;
+          const h = heading(lane);
+          if (h)
+            out.push(h);
+          out.push(...lines[i].slice(0, counts2[i]));
+        });
+        return out.join("\n");
+      };
+      const total = lines.reduce((n, l) => n + l.length, 0);
+      if (maxChars <= 0)
+        return { text: render(lines.map((l) => l.length)), truncated: false };
+      const more = (hidden) => `(+${hidden} more: brainfile brief${agent ? ` --agent ${agent}` : ""} --max-chars 0)`;
+      const fits = (counts2) => {
+        const shown2 = counts2.reduce((a, b) => a + b, 0);
+        const text2 = render(counts2);
+        return (shown2 < total ? `${text2}
+${more(total - shown2)}` : text2).length <= maxChars;
+      };
+      const counts = lines.map(() => 1);
+      const full = lines.map((l) => l[0]);
+      if (!fits(counts)) {
+        const MIN_LINE = 16;
+        for (let i = 0; i < lanes.length; i++) {
+          counts[i] = 0;
+          lines[i][0] = full[i].length > MIN_LINE ? clip(full[i], MIN_LINE) : full[i];
+        }
+        for (let i = 0; i < lanes.length; i++) {
+          counts[i] = 1;
+          if (!fits(counts))
+            counts[i] = 0;
+        }
+        for (let grew = true; grew; ) {
+          grew = false;
+          for (let i = 0; i < lanes.length; i++) {
+            if (counts[i] === 0 || lines[i][0] === full[i])
+              continue;
+            const before = lines[i][0];
+            const next = before.length + 10;
+            lines[i][0] = next >= full[i].length ? full[i] : clip(full[i], next);
+            if (fits(counts))
+              grew = true;
+            else
+              lines[i][0] = before;
+          }
+        }
+      }
+      for (let i = 0; i < lanes.length; i++) {
+        while (counts[i] > 0 && counts[i] < lines[i].length) {
+          counts[i]++;
+          if (!fits(counts)) {
+            counts[i]--;
+            break;
+          }
+        }
+      }
+      const shown = counts.reduce((a, b) => a + b, 0);
+      let text = render(counts);
+      if (shown < total)
+        text = `${text}
+${more(total - shown)}`;
+      if (text.length > maxChars)
+        text = clip(text, maxChars);
+      return { text, truncated: shown < total };
+    }
+  }
+});
+
+// ../core/dist/memory/check.js
+var require_check = __commonJS({
+  "../core/dist/memory/check.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.checkExitCode = checkExitCode;
+    exports.checkDecision = checkDecision;
+    exports.checkClaimKeyPrefix = checkClaimKeyPrefix;
+    var path2 = __importStar(__require("path"));
+    var boardFile_1 = require_boardFile();
+    var workspace_1 = require_workspace();
+    var decisions_1 = require_decisions();
+    var decisionOperations_1 = require_decisionOperations();
+    var memoryIndex_1 = require_memoryIndex();
+    function checkExitCode(verdict) {
+      if (verdict === "review")
+        return 2;
+      if (verdict === "use_replacement")
+        return 3;
+      return 0;
+    }
+    function load(brainfilePath, options) {
+      const dirs = (0, workspace_1.getV2Dirs)(brainfilePath);
+      const types = (0, boardFile_1.readBoardConfig)(dirs.brainfilePath)?.config.types;
+      const docs = (0, decisionOperations_1.readDecisionDocs)(dirs, types);
+      return { docs, tasks: docs.map((d) => d.task), types, projectRoot: options.projectRoot ?? path2.dirname(dirs.dotDir) };
+    }
+    function familyTasks(loaded, key) {
+      return loaded.tasks.filter((task) => (0, decisions_1.decisionFamilyKey)(task) === key);
+    }
+    function assess(loaded, options, key, targetKind, matched) {
+      const now = options.now ?? Date.now();
+      return (0, decisions_1.assessDecisionFamily)({
+        ...options.query ? { query: options.query } : {},
+        claimKey: key,
+        targetKind,
+        ...matched ? { matched } : {},
+        family: familyTasks(loaded, key),
+        evaluate: (task) => (0, decisionOperations_1.evaluateDecisionPredicates)(task, { projectRoot: loaded.projectRoot, now })
+      });
+    }
+    function scanCandidates(loaded, query) {
+      const tokens = (0, decisions_1.significantTokens)(query, decisions_1.ACTION_CUE_WORDS);
+      if (tokens.length === 0)
+        return [];
+      return loaded.docs.map((doc) => ({ task: doc.task, coverage: (0, decisions_1.tokenCoverage)(tokens, (0, decisions_1.decisionSearchText)(doc.task, doc.body)) })).filter((c) => c.coverage > 0).sort((a, b) => b.coverage - a.coverage).map((c) => c.task);
+    }
+    function checkDecision(brainfilePath, options) {
+      const loaded = load(brainfilePath, options);
+      const query = options.query?.trim() ?? "";
+      if (options.claimKey?.trim()) {
+        const key = (0, decisions_1.normalizeClaimKey)(options.claimKey);
+        const byId = loaded.tasks.find((t) => t.id === options.claimKey.trim());
+        const familyKey = familyTasks(loaded, key).length > 0 ? key : byId ? (0, decisions_1.decisionFamilyKey)(byId) : key;
+        return { matchedBy: "claim_key", result: assess(loaded, { ...options, query }, familyKey, "claim_key") };
+      }
+      if (!query)
+        return { matchedBy: "none", result: (0, decisions_1.noDecisionResult)() };
+      if (!/\s/.test(query)) {
+        const named = loaded.tasks.find((t) => t.id === query);
+        if (named)
+          return { matchedBy: "decision", result: assess(loaded, options, (0, decisions_1.decisionFamilyKey)(named), "decision", named) };
+        const key = (0, decisions_1.normalizeClaimKey)(query);
+        if (loaded.tasks.some((t) => (0, decisions_1.claimKeyOf)(t) === key)) {
+          return { matchedBy: "claim_key", result: assess(loaded, { ...options, query: "" }, key, "claim_key") };
+        }
+      }
+      let candidates = [];
+      let matchedBy = "none";
+      if (!options.scan) {
+        const index = memoryIndex_1.MemoryIndex.open(brainfilePath);
+        if (index) {
+          try {
+            index.refresh();
+            const ids = index.decisionCandidates(query, { ignoreWords: decisions_1.ACTION_CUE_WORDS });
+            candidates = ids.map((id) => loaded.tasks.find((t) => t.id === id)).filter((t) => Boolean(t));
+            matchedBy = "index";
+          } catch {
+            candidates = [];
+          } finally {
+            index.close();
+          }
+        }
+      }
+      if (matchedBy === "none") {
+        candidates = scanCandidates(loaded, query);
+        matchedBy = "scan";
+      }
+      const matched = candidates[0];
+      if (!matched)
+        return { matchedBy, result: (0, decisions_1.noDecisionResult)(query) };
+      return { matchedBy, result: assess(loaded, options, (0, decisions_1.decisionFamilyKey)(matched), "query", matched) };
+    }
+    function checkClaimKeyPrefix(brainfilePath, prefix, options = {}) {
+      const loaded = load(brainfilePath, options);
+      const families = (0, decisions_1.groupDecisionFamilies)(loaded.tasks, loaded.types).filter((family) => family.claimKey && (0, decisions_1.claimKeyMatchesPrefix)(family.claimKey, prefix));
+      const results = families.map((family) => assess(loaded, { ...options, query: options.query ?? "" }, family.key, "claim_key"));
+      const worst = (0, decisions_1.worstCheckResult)(results);
+      return {
+        claimKeyPrefix: (0, decisions_1.normalizeClaimKey)(prefix),
+        verdict: worst?.verdict ?? "no_decision",
+        recommendation: worst?.recommendation ?? "proceed_without_memory",
+        reason: worst?.reason ?? "no_claim_key_match",
+        ...worst?.claimKey ? { decidingClaimKey: worst.claimKey } : {},
+        familyCount: results.length,
+        families: results
+      };
+    }
+  }
+});
+
+// ../core/dist/memory/index.js
+var require_memory = __commonJS({
+  "../core/dist/memory/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_sqlite(), exports);
+    __exportStar(require_chunk(), exports);
+    __exportStar(require_mine(), exports);
+    __exportStar(require_memoryIndex(), exports);
+    __exportStar(require_search2(), exports);
+    __exportStar(require_brief2(), exports);
+    __exportStar(require_check(), exports);
+  }
+});
+
+// src/hooks/session-start.ts
+var import_core = __toESM(require_dist());
+var import_memory = __toESM(require_memory());
+import * as path from "path";
+var HOOK_REFRESH_BUDGET_MS = 120;
+function hookCaller(input) {
+  if (!input) return "unknown";
+  if (input.clineVersion && input.hookName) return "cline";
+  const event = typeof input.hook_event_name === "string" ? input.hook_event_name : "";
+  if (event === "SessionStart") return "claude-code";
+  if (event === "stop") return "cursor";
+  return "unknown";
+}
+function clean(name) {
+  return (name ?? "").replace(/[[\]<>\r\n]/g, "").trim();
+}
+function hookAgent(caller, env = process.env) {
+  const named = clean(env.BRAINFILE_AGENT);
+  if (named) return named;
+  if (caller === "claude-code") return "claude";
+  if (caller === "cline") return "cline";
+  if (caller === "cursor") return "cursor";
+  if (env.CODEX_THREAD_ID || env.CODEX_SESSION_ID) return "codex";
+  if (env.GEMINI_CLI === "1") return "gemini";
+  if (env.CLAUDECODE === "1") return "claude";
+  return "agent";
+}
+function budget(env) {
+  const n = Number.parseInt(env.BRAINFILE_BRIEF_MAX_CHARS ?? "", 10);
+  return Number.isFinite(n) && n >= 0 ? n : import_memory.DEFAULT_BRIEF_MAX_CHARS;
+}
+function sessionStartOutput(input, env = process.env) {
+  try {
+    const cwd = typeof input?.cwd === "string" && input.cwd ? input.cwd : process.cwd();
+    const found = (0, import_core.findBrainfile)(cwd, { stopAtGitRoot: true });
+    if (!found || found.kind !== "dotdir") return null;
+    const caller = hookCaller(input);
+    if (caller === "cursor") {
+      return `\u2705 Brainfile detected: @${path.basename(found.absolutePath)}
+Remember to update task status as you work.`;
+    }
+    if (!(0, import_core.isV2)(found.absolutePath)) return null;
+    const agent = hookAgent(caller, env);
+    const state = (0, import_core.readBriefState)(found.absolutePath, agent);
+    const brief = (0, import_memory.composeBrief)((0, import_core.getV2Dirs)(found.absolutePath), agent, {
+      lastBriefAt: state.lastBriefAt,
+      maxChars: budget(env),
+      refreshBudgetMs: HOOK_REFRESH_BUDGET_MS
+    });
+    try {
+      (0, import_core.writeBriefState)(found.absolutePath, agent, brief.generatedAt);
+    } catch {
+    }
+    if (caller === "claude-code") {
+      return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: brief.text } });
+    }
+    return brief.text;
+  } catch {
+    return null;
+  }
+}
+function readHookInput(stdin = process.stdin, timeoutMs = 1500) {
+  if (stdin.isTTY) return Promise.resolve({});
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try {
+        const parsed = JSON.parse(data);
+        resolve(parsed && typeof parsed === "object" ? parsed : {});
+      } catch {
+        resolve({});
+      }
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin.setEncoding?.("utf-8");
+    stdin.on("data", (chunk) => {
+      data += String(chunk);
+    });
+    stdin.on("end", finish);
+    stdin.on("error", finish);
+  });
+}
+async function runSessionStartHook(stdin = process.stdin, write = (text) => process.stdout.write(text), env = process.env) {
+  const input = await readHookInput(stdin);
+  const out = sessionStartOutput(input, env);
+  if (out) write(`${out}
+`);
+  if (stdin === process.stdin) {
+    process.stdin.pause();
+    process.stdin.unref?.();
+  }
+}
+
+export {
+  require_memory,
+  sessionStartOutput,
+  runSessionStartHook
+};