devsmind-mcp 2.4.0 → 4.0.0

package/dist/db/revert.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revertLastEdit = revertLastEdit;
+const staging_1 = require("./staging");
+const edit_1 = require("../utils/edit");
+const ast_1 = require("../utils/ast");
+/**
+ * Undoes the most recent recorded edit to one entity: restores the file, then erases what was
+ * written about it.
+ *
+ * Only the newest edit is reversible. An older one cannot be undone in isolation — every edit
+ * after it was made against the code it produced, so putting its "before" back would overwrite
+ * work that has nothing to do with it. Git is the tool for that, and it already does it properly.
+ *
+ * `expectedHistoryId`, when given, is the specific entry the caller intended to revert (e.g. the
+ * one a "Revert this change" button was clicked on). It must match the node's actual latest entry
+ * — if it doesn't (a newer entry was recorded since, perhaps from another session), the revert is
+ * refused rather than silently reverting that newer entry instead, which would undo the wrong
+ * change from the caller's point of view.
+ *
+ * The file is restored by swapping the recorded `after` back to the recorded `before`, which
+ * routes through the same exact-match write `edit_node` uses: if that text is no longer uniquely
+ * present, the write is refused rather than guessed at.
+ */
+function revertLastEdit(db, devmindPath, nodeId, expectedHistoryId) {
+    const node = db.getNode(nodeId);
+    const resolvedId = node ? node.id : nodeId;
+    // Staged edits are the newest thing that happened, and were never recorded — undo those first,
+    // or a revert would restore the file underneath a staged entry still waiting to be committed.
+    const staged = (0, staging_1.readStaged)(devmindPath).filter(e => e.node_id === resolvedId);
+    if (staged.length) {
+        const last = staged[staged.length - 1];
+        if (last.code_before === undefined) {
+            return { ok: false, error: `The staged change to ${resolvedId} has no recorded before-state, so it cannot be undone here. Use git to restore the file.` };
+        }
+        const restored = restoreFile(last.file_path, last.code_snapshot, last.code_before ?? '');
+        if (!restored.ok)
+            return { ok: false, error: restored.error, node_id: resolvedId, file_path: last.file_path };
+        (0, staging_1.removeLastStagedEntry)(devmindPath, resolvedId);
+        return { ok: true, node_id: resolvedId, file_path: last.file_path, was_staged: true };
+    }
+    const entry = db.getLatestHistory(resolvedId);
+    if (!entry)
+        return { ok: false, error: `No history recorded for ${resolvedId} — nothing to revert.` };
+    if (expectedHistoryId && entry.id !== expectedHistoryId) {
+        return {
+            ok: false,
+            error: `A newer change to ${resolvedId} was recorded since this one — reverting it would undo that newer change instead. Refresh and revert the newest entry, or use git.`,
+            node_id: resolvedId
+        };
+    }
+    if (!entry.edits.length) {
+        return {
+            ok: false,
+            error: `The last change to ${resolvedId} was recorded without a before-state, so there is nothing to restore it to. Entries written before edit_node tracked diffs, and legacy update_history / initial index snapshots, are both like this. Use git to restore the file.`
+        };
+    }
+    const last = entry.edits[entry.edits.length - 1];
+    if (!node)
+        return { ok: false, error: `${resolvedId} has history but no node in the graph — cannot locate its file.` };
+    // The recorded `after` must still be what is on disk. If it isn't, the code moved on after this
+    // edit and restoring `before` would silently discard whatever came since.
+    const live = db.getLiveCode(resolvedId);
+    if (live.source !== 'live' || live.code === undefined) {
+        return {
+            ok: false,
+            error: `Could not read ${resolvedId} from disk to confirm what is there now (the symbol may have been renamed, moved, or deleted). Revert refused — use git.`,
+            node_id: resolvedId
+        };
+    }
+    if (live.code !== last.after) {
+        return {
+            ok: false,
+            error: `${resolvedId} has changed since that edit was recorded — reverting would discard the newer change. Revert refused; use git to restore the file.`,
+            node_id: resolvedId,
+            file_path: node.file_path
+        };
+    }
+    const restored = restoreFile(node.file_path, last.after, last.before);
+    if (!restored.ok)
+        return { ok: false, error: restored.error, node_id: resolvedId, file_path: node.file_path };
+    const erased = db.eraseLastEdit(entry.id);
+    return {
+        ok: true,
+        node_id: resolvedId,
+        file_path: node.file_path,
+        entry_deleted: erased.entry_deleted,
+        note: erased.entry_deleted ? undefined : erased.reason
+    };
+}
+/**
+ * Swaps `after` back to `before` in the file.
+ *
+ * `before` is empty when the edit created the entity, so the revert deletes it — which is the
+ * correct inverse, and the one case where the two strings could not both be present.
+ */
+function restoreFile(filePath, after, before) {
+    const paths = String(filePath).split(',').map(s => s.trim()).filter(Boolean);
+    const target = paths[0];
+    if (!target)
+        return { ok: false, error: 'no file path recorded for this entity' };
+    const r = (0, edit_1.replaceTextInFile)(target, after, before, false);
+    if (!r.ok)
+        return { ok: false, error: `could not restore ${target}: ${r.error}` };
+    (0, ast_1.invalidateParsedFile)(target);
+    return { ok: true };
+}
+//# sourceMappingURL=revert.js.map

package/dist/db/revert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revert.js","sourceRoot":"","sources":["../../src/db/revert.ts"],"names":[],"mappings":"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"}

package/dist/db/schema.d.ts

@@ -4,6 +4,22 @@ export interface DbNode {
     name: string;
     file_path: string;
     signature: string | null;
+    /**
+     * A 1-3 sentence natural-language description of what this entity does — the thing a plain
+     * identifier can't carry. This is what makes `search_nodes` findable by natural language
+     * instead of only by exact identifier/path substring. Null until an agent (or `devsmind
+     * describe`) writes one; `commit_changes` refuses to create a NEW node without it.
+     */
+    description: string | null;
+    /**
+     * Other names this SAME entity is referenced by — a generated hook (`useGetAdminOrdersQuery`
+     * for an RTK `getAdminOrders` endpoint), a renamed default-export import, or an `export { x as
+     * y }` re-export. One implementation, several exported handles: this is what lets the edge
+     * resolver match a caller against ANY of them instead of only the entity's own declared name,
+     * which is the fix for edges that otherwise can't exist because the reference in the code never
+     * spells out the original name at all. Empty array, not null, when there are none.
+     */
+    aliases: string[];
     deprecated: number;
     created_at: string;
 }
@@ -11,6 +27,13 @@ export interface DbConnection {
     source_node_id: string;
     target_node_id: string;
 }
+/** One recorded edit within a history entry — what the code looked like either side of it. */
+export interface HistoryEdit {
+    at: string;
+    before: string;
+    after: string;
+    reasoning: string;
+}
 export interface DbHistory {
     id: string;
     node_id: string;
@@ -19,12 +42,21 @@ export interface DbHistory {
     updated_at: string;
     code_snapshot: string;
     reasoning: string;
+    /**
+     * Per-edit before/after trail, newest last. Lives only in the history JSON, never in SQLite —
+     * same as code_snapshot. Empty for entries written before this existed, and for legacy
+     * `update_history` / initial index snapshots, which have no before-state to record: both mean "no diff, no revert".
+     */
+    edits: HistoryEdit[];
 }
 export interface DbWorkflow {
     id: string;
     name: string;
     description: string;
-    status: 'active' | 'paused' | 'completed';
+    /** 1 = hidden from the default listing. Replaces the old `status` field: nothing ever genuinely
+     * "completes" — a feature keeps getting changed — so a completed/paused/active lifecycle was a
+     * value nobody maintained. "Archived" claims only what it can deliver: hide this from the list. */
+    archived: number;
     created_at: string;
     updated_at: string;
 }
@@ -33,8 +65,21 @@ export interface DbWorkflowStep {
     workflow_id: string;
     step_index: number;
     summary: string;
-    pending_tasks: string | null;
-    history_ids: string | null;
+    /** The commit's own `why`/`goal`/`decision`, copied at write time rather than joined from
+     * `history`. Deliberate duplication: history reasoning MUTATES after the fact (the 1-hour merge
+     * appends under a `── Update @ … ──` separator, and eraseLastEdit can drop a block), so a step
+     * that joined to it would describe a moving target — disqualifying for a record whose whole
+     * purpose is "what did we think at the time". */
+    reasoning: string | null;
+    /** JSON array of the node ids this step touched. Replaces `history_ids`, which could not
+     * identify a commit: within an hour, two commits on the same node merge into ONE history row,
+     * so a step's ids could point at rows an earlier commit created, and one row could be cited by
+     * several steps. Node ids have no such ambiguity and are directly usable with get_node_code. */
+    node_ids: string | null;
+    /** JSON array of repo-relative paths to research/spec docs behind this step. A path, never a
+     * copy: the file is already versioned and already shared, so it cannot go stale the way the old
+     * `workflow_artifacts` content duplicates did. */
+    doc_paths: string | null;
     session_id: string | null;
     created_at: string;
 }
@@ -47,4 +92,4 @@ export interface DbWorkflowArtifact {
     file_path: string;
     created_at: string;
 }
-export declare const INIT_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS nodes (\n  id          TEXT PRIMARY KEY,\n  type        TEXT NOT NULL,\n  name        TEXT NOT NULL,\n  file_path   TEXT NOT NULL,\n  signature   TEXT,\n  deprecated  INTEGER DEFAULT 0,\n  created_at  DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\nCREATE TABLE IF NOT EXISTS node_connections (\n  source_node_id  TEXT,\n  target_node_id  TEXT,\n  PRIMARY KEY (source_node_id, target_node_id),\n  FOREIGN KEY (source_node_id) REFERENCES nodes (id) ON DELETE CASCADE,\n  FOREIGN KEY (target_node_id) REFERENCES nodes (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS history (\n  id             TEXT PRIMARY KEY,\n  node_id        TEXT NOT NULL,\n  session_id     TEXT NOT NULL,\n  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  code_snapshot  TEXT NOT NULL,\n  reasoning      TEXT NOT NULL,\n  FOREIGN KEY (node_id) REFERENCES nodes (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS system_meta (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\nCREATE TABLE IF NOT EXISTS workflows (\n  id           TEXT PRIMARY KEY,\n  name         TEXT NOT NULL,\n  description  TEXT NOT NULL,\n  status       TEXT NOT NULL DEFAULT 'active',\n  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\nCREATE TABLE IF NOT EXISTS workflow_steps (\n  id             TEXT PRIMARY KEY,\n  workflow_id    TEXT NOT NULL,\n  step_index     INTEGER NOT NULL,\n  summary        TEXT NOT NULL,\n  pending_tasks  TEXT,\n  history_ids    TEXT,\n  session_id     TEXT,\n  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS workflow_artifacts (\n  id            TEXT PRIMARY KEY,\n  workflow_id   TEXT NOT NULL,\n  step_id       TEXT,\n  type          TEXT NOT NULL,\n  source_name   TEXT NOT NULL,\n  file_path     TEXT NOT NULL,\n  created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE\n);\n\n-- Index for searching nodes by name and type\nCREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes (name);\nCREATE INDEX IF NOT EXISTS idx_history_node_id ON history (node_id);\nCREATE INDEX IF NOT EXISTS idx_workflow_steps_workflow_id ON workflow_steps (workflow_id);\nCREATE INDEX IF NOT EXISTS idx_workflow_artifacts_workflow_id ON workflow_artifacts (workflow_id);\n";
+export declare const INIT_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS nodes (\n  id          TEXT PRIMARY KEY,\n  type        TEXT NOT NULL,\n  name        TEXT NOT NULL,\n  file_path   TEXT NOT NULL,\n  signature   TEXT,\n  description TEXT,\n  aliases     TEXT DEFAULT '[]',\n  deprecated  INTEGER DEFAULT 0,\n  created_at  DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\nCREATE TABLE IF NOT EXISTS node_connections (\n  source_node_id  TEXT,\n  target_node_id  TEXT,\n  PRIMARY KEY (source_node_id, target_node_id),\n  FOREIGN KEY (source_node_id) REFERENCES nodes (id) ON DELETE CASCADE,\n  FOREIGN KEY (target_node_id) REFERENCES nodes (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS history (\n  id             TEXT PRIMARY KEY,\n  node_id        TEXT NOT NULL,\n  session_id     TEXT NOT NULL,\n  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  code_snapshot  TEXT NOT NULL,\n  reasoning      TEXT NOT NULL,\n  FOREIGN KEY (node_id) REFERENCES nodes (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS system_meta (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\n-- Local, derived search index \u2014 never synced or committed, purely a cache rebuilt from\n-- nodes+history whenever search-index.ts's fingerprint check finds it stale. Same category as\n-- brain.db itself: safe to wipe and rebuild from the source of truth at any time.\nCREATE TABLE IF NOT EXISTS node_tokens (\n  node_id  TEXT NOT NULL,\n  token    TEXT NOT NULL,\n  field    TEXT NOT NULL,\n  tf       INTEGER NOT NULL DEFAULT 1,\n  PRIMARY KEY (node_id, token, field)\n);\nCREATE INDEX IF NOT EXISTS idx_node_tokens_token ON node_tokens (token);\n\n-- Semantic (dense) vectors, one per node, from the vendored ONNX embedder (src/db/embedder.ts).\n-- Unlike node_tokens, these ARE synced via git (vectors/**/*.json, mirroring graph/**/*.json) \u2014\n-- deliberately, per an explicit product decision to trade repo size for teammates skipping local\n-- inference. No foreign key to nodes(id): syncFromDisk() runs its destructive graph pass under\n-- foreign_keys=OFF, so a cascade here would silently never fire; orphans are swept explicitly\n-- instead (see syncFromDisk's vectors pass). model_id guards the git-sync hazard \u2014 vectors from\n-- a different embedding model are structurally valid but numerically meaningless, so any reader\n-- MUST check model_id before trusting a row, not just check for its presence.\nCREATE TABLE IF NOT EXISTS node_vectors (\n  node_id          TEXT PRIMARY KEY,\n  model_id         TEXT NOT NULL,\n  dim              INTEGER NOT NULL,\n  description_hash TEXT NOT NULL,\n  vector           BLOB NOT NULL\n);\n\n-- status is vestigial: still declared (NOT NULL DEFAULT makes an INSERT that omits it succeed)\n-- but no longer read or written. archived replaces it -- see DbWorkflow.\nCREATE TABLE IF NOT EXISTS workflows (\n  id           TEXT PRIMARY KEY,\n  name         TEXT NOT NULL,\n  description  TEXT NOT NULL,\n  status       TEXT NOT NULL DEFAULT 'active',\n  archived     INTEGER NOT NULL DEFAULT 0,\n  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\n-- pending_tasks and history_ids are vestigial: never written or read by current code, and kept\n-- only so an older CLI opening the same brain.db does not hit \"no such column\". They are dropped\n-- from DbWorkflowStep, so nothing in TypeScript can reach them by accident.\nCREATE TABLE IF NOT EXISTS workflow_steps (\n  id             TEXT PRIMARY KEY,\n  workflow_id    TEXT NOT NULL,\n  step_index     INTEGER NOT NULL,\n  summary        TEXT NOT NULL,\n  reasoning      TEXT,\n  node_ids       TEXT,\n  doc_paths      TEXT,\n  pending_tasks  TEXT,\n  history_ids    TEXT,\n  session_id     TEXT,\n  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS workflow_artifacts (\n  id            TEXT PRIMARY KEY,\n  workflow_id   TEXT NOT NULL,\n  step_id       TEXT,\n  type          TEXT NOT NULL,\n  source_name   TEXT NOT NULL,\n  file_path     TEXT NOT NULL,\n  created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE\n);\n\n-- Index for searching nodes by name and type\nCREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes (name);\n-- Matches getNodesByFilePath's own normalization (REPLACE(LOWER(file_path), '', '/')) exactly \u2014\n-- without this, that call is a full table scan, and get_node_code's file_outline now puts it on\n-- the hot path of the most-called read tool (once per call, to cross-reference outline entries\n-- against indexed nodes). Idempotent: existing brains pick this up on next open, no migration.\nCREATE INDEX IF NOT EXISTS idx_nodes_file_path ON nodes (REPLACE(LOWER(file_path), '', '/'));\n-- node_connections' PRIMARY KEY is (source_node_id, target_node_id), so its autoindex serves\n-- \"what does X use\" but NOT the reverse. Every \"who uses X\" lookup \u2014 the inbound half of getGraph's\n-- BFS, getConnections' used_by, getConnectionCounts \u2014 was therefore a full table scan, and the BFS\n-- runs one PER NODE VISITED (up to 500 in a single call). The trailing source_node_id makes this\n-- covering, so the inbound query is answered from the index alone and comes back already ordered\n-- (which is what makes getGraph's ORDER BY free rather than a sort on top of a scan).\n-- Idempotent: existing brains pick this up on next open, no migration.\nCREATE INDEX IF NOT EXISTS idx_node_connections_target ON node_connections (target_node_id, source_node_id);\nCREATE INDEX IF NOT EXISTS idx_history_node_id ON history (node_id);\nCREATE INDEX IF NOT EXISTS idx_workflow_steps_workflow_id ON workflow_steps (workflow_id);\nCREATE INDEX IF NOT EXISTS idx_workflow_artifacts_workflow_id ON workflow_artifacts (workflow_id);\n";

package/dist/db/schema.js

@@ -1,78 +1,130 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INIT_SCHEMA_SQL = void 0;
-exports.INIT_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS nodes (
-  id          TEXT PRIMARY KEY,
-  type        TEXT NOT NULL,
-  name        TEXT NOT NULL,
-  file_path   TEXT NOT NULL,
-  signature   TEXT,
-  deprecated  INTEGER DEFAULT 0,
-  created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS node_connections (
-  source_node_id  TEXT,
-  target_node_id  TEXT,
-  PRIMARY KEY (source_node_id, target_node_id),
-  FOREIGN KEY (source_node_id) REFERENCES nodes (id) ON DELETE CASCADE,
-  FOREIGN KEY (target_node_id) REFERENCES nodes (id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS history (
-  id             TEXT PRIMARY KEY,
-  node_id        TEXT NOT NULL,
-  session_id     TEXT NOT NULL,
-  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updated_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
-  code_snapshot  TEXT NOT NULL,
-  reasoning      TEXT NOT NULL,
-  FOREIGN KEY (node_id) REFERENCES nodes (id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS system_meta (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL,
-  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS workflows (
-  id           TEXT PRIMARY KEY,
-  name         TEXT NOT NULL,
-  description  TEXT NOT NULL,
-  status       TEXT NOT NULL DEFAULT 'active',
-  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS workflow_steps (
-  id             TEXT PRIMARY KEY,
-  workflow_id    TEXT NOT NULL,
-  step_index     INTEGER NOT NULL,
-  summary        TEXT NOT NULL,
-  pending_tasks  TEXT,
-  history_ids    TEXT,
-  session_id     TEXT,
-  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
-  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS workflow_artifacts (
-  id            TEXT PRIMARY KEY,
-  workflow_id   TEXT NOT NULL,
-  step_id       TEXT,
-  type          TEXT NOT NULL,
-  source_name   TEXT NOT NULL,
-  file_path     TEXT NOT NULL,
-  created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,
-  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE
-);
-
--- Index for searching nodes by name and type
-CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes (name);
-CREATE INDEX IF NOT EXISTS idx_history_node_id ON history (node_id);
-CREATE INDEX IF NOT EXISTS idx_workflow_steps_workflow_id ON workflow_steps (workflow_id);
-CREATE INDEX IF NOT EXISTS idx_workflow_artifacts_workflow_id ON workflow_artifacts (workflow_id);
+exports.INIT_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS nodes (
+  id          TEXT PRIMARY KEY,
+  type        TEXT NOT NULL,
+  name        TEXT NOT NULL,
+  file_path   TEXT NOT NULL,
+  signature   TEXT,
+  description TEXT,
+  aliases     TEXT DEFAULT '[]',
+  deprecated  INTEGER DEFAULT 0,
+  created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS node_connections (
+  source_node_id  TEXT,
+  target_node_id  TEXT,
+  PRIMARY KEY (source_node_id, target_node_id),
+  FOREIGN KEY (source_node_id) REFERENCES nodes (id) ON DELETE CASCADE,
+  FOREIGN KEY (target_node_id) REFERENCES nodes (id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS history (
+  id             TEXT PRIMARY KEY,
+  node_id        TEXT NOT NULL,
+  session_id     TEXT NOT NULL,
+  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
+  code_snapshot  TEXT NOT NULL,
+  reasoning      TEXT NOT NULL,
+  FOREIGN KEY (node_id) REFERENCES nodes (id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS system_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Local, derived search index — never synced or committed, purely a cache rebuilt from
+-- nodes+history whenever search-index.ts's fingerprint check finds it stale. Same category as
+-- brain.db itself: safe to wipe and rebuild from the source of truth at any time.
+CREATE TABLE IF NOT EXISTS node_tokens (
+  node_id  TEXT NOT NULL,
+  token    TEXT NOT NULL,
+  field    TEXT NOT NULL,
+  tf       INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (node_id, token, field)
+);
+CREATE INDEX IF NOT EXISTS idx_node_tokens_token ON node_tokens (token);
+
+-- Semantic (dense) vectors, one per node, from the vendored ONNX embedder (src/db/embedder.ts).
+-- Unlike node_tokens, these ARE synced via git (vectors/**/*.json, mirroring graph/**/*.json) —
+-- deliberately, per an explicit product decision to trade repo size for teammates skipping local
+-- inference. No foreign key to nodes(id): syncFromDisk() runs its destructive graph pass under
+-- foreign_keys=OFF, so a cascade here would silently never fire; orphans are swept explicitly
+-- instead (see syncFromDisk's vectors pass). model_id guards the git-sync hazard — vectors from
+-- a different embedding model are structurally valid but numerically meaningless, so any reader
+-- MUST check model_id before trusting a row, not just check for its presence.
+CREATE TABLE IF NOT EXISTS node_vectors (
+  node_id          TEXT PRIMARY KEY,
+  model_id         TEXT NOT NULL,
+  dim              INTEGER NOT NULL,
+  description_hash TEXT NOT NULL,
+  vector           BLOB NOT NULL
+);
+
+-- status is vestigial: still declared (NOT NULL DEFAULT makes an INSERT that omits it succeed)
+-- but no longer read or written. archived replaces it -- see DbWorkflow.
+CREATE TABLE IF NOT EXISTS workflows (
+  id           TEXT PRIMARY KEY,
+  name         TEXT NOT NULL,
+  description  TEXT NOT NULL,
+  status       TEXT NOT NULL DEFAULT 'active',
+  archived     INTEGER NOT NULL DEFAULT 0,
+  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- pending_tasks and history_ids are vestigial: never written or read by current code, and kept
+-- only so an older CLI opening the same brain.db does not hit "no such column". They are dropped
+-- from DbWorkflowStep, so nothing in TypeScript can reach them by accident.
+CREATE TABLE IF NOT EXISTS workflow_steps (
+  id             TEXT PRIMARY KEY,
+  workflow_id    TEXT NOT NULL,
+  step_index     INTEGER NOT NULL,
+  summary        TEXT NOT NULL,
+  reasoning      TEXT,
+  node_ids       TEXT,
+  doc_paths      TEXT,
+  pending_tasks  TEXT,
+  history_ids    TEXT,
+  session_id     TEXT,
+  created_at     DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS workflow_artifacts (
+  id            TEXT PRIMARY KEY,
+  workflow_id   TEXT NOT NULL,
+  step_id       TEXT,
+  type          TEXT NOT NULL,
+  source_name   TEXT NOT NULL,
+  file_path     TEXT NOT NULL,
+  created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (workflow_id) REFERENCES workflows (id) ON DELETE CASCADE
+);
+
+-- Index for searching nodes by name and type
+CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes (name);
+-- Matches getNodesByFilePath's own normalization (REPLACE(LOWER(file_path), '\', '/')) exactly —
+-- without this, that call is a full table scan, and get_node_code's file_outline now puts it on
+-- the hot path of the most-called read tool (once per call, to cross-reference outline entries
+-- against indexed nodes). Idempotent: existing brains pick this up on next open, no migration.
+CREATE INDEX IF NOT EXISTS idx_nodes_file_path ON nodes (REPLACE(LOWER(file_path), '\', '/'));
+-- node_connections' PRIMARY KEY is (source_node_id, target_node_id), so its autoindex serves
+-- "what does X use" but NOT the reverse. Every "who uses X" lookup — the inbound half of getGraph's
+-- BFS, getConnections' used_by, getConnectionCounts — was therefore a full table scan, and the BFS
+-- runs one PER NODE VISITED (up to 500 in a single call). The trailing source_node_id makes this
+-- covering, so the inbound query is answered from the index alone and comes back already ordered
+-- (which is what makes getGraph's ORDER BY free rather than a sort on top of a scan).
+-- Idempotent: existing brains pick this up on next open, no migration.
+CREATE INDEX IF NOT EXISTS idx_node_connections_target ON node_connections (target_node_id, source_node_id);
+CREATE INDEX IF NOT EXISTS idx_history_node_id ON history (node_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_steps_workflow_id ON workflow_steps (workflow_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_artifacts_workflow_id ON workflow_artifacts (workflow_id);
 `;
 //# sourceMappingURL=schema.js.map

package/dist/db/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":";;;AAuDa,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyE9B,CAAC"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":";;;AAqGa,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6H9B,CAAC"}

package/dist/db/search-index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The searchable "surface" of a node, split into fields so each can carry its own relevance
+ * weight. `description` is the whole point of this module: without it, natural-language search
+ * has almost nothing to match against — an identifier and a file path are a handful of words.
+ */
+export type TokenField = 'identifier' | 'path' | 'description' | 'reasoning';
+export interface TokenRow {
+    token: string;
+    field: TokenField;
+    /** Term frequency — how many times this token appears in this field, for this node. */
+    tf: number;
+}
+/**
+ * Tokenizes one field's text into deduplicated (token, tf) pairs, ready to write into
+ * `node_tokens`. `identifier`/`path` fields use the identifier splitter (camelCase/snake/kebab
+ * boundaries) since that's what they actually are; `description`/`reasoning` use the plain
+ * natural-language tokenizer since they're already prose.
+ */
+export declare function tokenizeNodeField(text: string | null | undefined, field: TokenField): TokenRow[];
+export interface FieldWeights {
+    identifier: number;
+    path: number;
+    description: number;
+    reasoning: number;
+}
+/**
+ * `description` outweighs everything else — it's the field written specifically to be found
+ * by natural language, so a hit there is the strongest possible signal that this is the right
+ * node. `identifier` is still weighted highly since an exact-ish name match is usually right.
+ * `reasoning` is last: it explains WHY something changed, not WHAT it is, so it's a weaker
+ * signal for "find the code that does X" than the other three.
+ */
+export declare const DEFAULT_FIELD_WEIGHTS: FieldWeights;
+export interface FieldMatch {
+    field: TokenField;
+    /** This node's term frequency for the matched token, in this field. */
+    tf: number;
+    /** How many OTHER nodes also have this token in this field — rarer tokens carry more signal. */
+    docFreq: number;
+    /** Total nodes considered, for the IDF calculation. */
+    totalNodes: number;
+}
+/**
+ * A saturating-TF, IDF-weighted score for one candidate node across every (field, token) it
+ * matched. This is BM25-shaped (the same `tf*(k1+1)/(tf+k1)` saturation and log-IDF term BM25
+ * uses) but deliberately simplified: it scores a small, already-narrowed candidate set (nodes
+ * that matched at least one query token via a SQL lookup), not a full-corpus scan, so there's
+ * no need for BM25's document-length normalization term — every "document" here is one node's
+ * handful of fields, not a variable-length passage.
+ */
+export declare function scoreCandidate(matches: FieldMatch[], weights?: FieldWeights): number;
+export interface RankedId {
+    id: string;
+    score: number;
+}
+/**
+ * Reciprocal Rank Fusion — merges the BM25 ranking and the vector-cosine ranking into one list,
+ * using each id's POSITION within each ranking rather than the raw scores. Necessary because
+ * BM25 scores are unbounded and cosine similarity is bounded [-1,1]; there's no principled scale
+ * to sum them on directly, but "1st place" means the same thing in both rankings. An id missing
+ * from a ranking simply contributes 0 from it — appearing in both rankings compounds naturally.
+ * k=60 is the standard RRF constant (Cormack et al.): large enough that rank 1 vs rank 2 isn't a
+ * cliff, small enough that being ranked at all still matters more than being buried at rank 500.
+ */
+export declare function reciprocalRankFusion(rankings: string[][], k?: number): RankedId[];

package/dist/db/search-index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FIELD_WEIGHTS = void 0;
+exports.tokenizeNodeField = tokenizeNodeField;
+exports.scoreCandidate = scoreCandidate;
+exports.reciprocalRankFusion = reciprocalRankFusion;
+const tokenize_1 = require("../utils/tokenize");
+/**
+ * Tokenizes one field's text into deduplicated (token, tf) pairs, ready to write into
+ * `node_tokens`. `identifier`/`path` fields use the identifier splitter (camelCase/snake/kebab
+ * boundaries) since that's what they actually are; `description`/`reasoning` use the plain
+ * natural-language tokenizer since they're already prose.
+ */
+function tokenizeNodeField(text, field) {
+    if (!text)
+        return [];
+    const tokens = field === 'identifier' || field === 'path' ? (0, tokenize_1.tokenizeIdentifier)(text) : (0, tokenize_1.tokenizeText)(text);
+    const counts = new Map();
+    for (const t of tokens)
+        counts.set(t, (counts.get(t) || 0) + 1);
+    return Array.from(counts.entries()).map(([token, tf]) => ({ token, field, tf }));
+}
+/**
+ * `description` outweighs everything else — it's the field written specifically to be found
+ * by natural language, so a hit there is the strongest possible signal that this is the right
+ * node. `identifier` is still weighted highly since an exact-ish name match is usually right.
+ * `reasoning` is last: it explains WHY something changed, not WHAT it is, so it's a weaker
+ * signal for "find the code that does X" than the other three.
+ */
+exports.DEFAULT_FIELD_WEIGHTS = {
+    description: 4,
+    identifier: 3,
+    path: 2,
+    reasoning: 1.5
+};
+/**
+ * A saturating-TF, IDF-weighted score for one candidate node across every (field, token) it
+ * matched. This is BM25-shaped (the same `tf*(k1+1)/(tf+k1)` saturation and log-IDF term BM25
+ * uses) but deliberately simplified: it scores a small, already-narrowed candidate set (nodes
+ * that matched at least one query token via a SQL lookup), not a full-corpus scan, so there's
+ * no need for BM25's document-length normalization term — every "document" here is one node's
+ * handful of fields, not a variable-length passage.
+ */
+function scoreCandidate(matches, weights = exports.DEFAULT_FIELD_WEIGHTS) {
+    const K1 = 1.2;
+    let score = 0;
+    for (const m of matches) {
+        const idf = Math.log(1 + (m.totalNodes - m.docFreq + 0.5) / (m.docFreq + 0.5));
+        const tfNorm = (m.tf * (K1 + 1)) / (m.tf + K1);
+        score += weights[m.field] * Math.max(idf, 0.01) * tfNorm;
+    }
+    return score;
+}
+/**
+ * Reciprocal Rank Fusion — merges the BM25 ranking and the vector-cosine ranking into one list,
+ * using each id's POSITION within each ranking rather than the raw scores. Necessary because
+ * BM25 scores are unbounded and cosine similarity is bounded [-1,1]; there's no principled scale
+ * to sum them on directly, but "1st place" means the same thing in both rankings. An id missing
+ * from a ranking simply contributes 0 from it — appearing in both rankings compounds naturally.
+ * k=60 is the standard RRF constant (Cormack et al.): large enough that rank 1 vs rank 2 isn't a
+ * cliff, small enough that being ranked at all still matters more than being buried at rank 500.
+ */
+function reciprocalRankFusion(rankings, k = 60) {
+    const scores = new Map();
+    for (const ranking of rankings) {
+        ranking.forEach((id, index) => {
+            scores.set(id, (scores.get(id) || 0) + 1 / (k + index + 1));
+        });
+    }
+    return Array.from(scores.entries())
+        .map(([id, score]) => ({ id, score }))
+        .sort((a, b) => b.score - a.score);
+}
+//# sourceMappingURL=search-index.js.map

package/dist/db/search-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-index.js","sourceRoot":"","sources":["../../src/db/search-index.ts"],"names":[],"mappings":"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"}