@davesheffer/hunch 0.12.0 → 0.12.2

package/dist/cli/index.js

@@ -17,14 +17,14 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { execFileSync, spawnSync } from "node:child_process";
 import { relative } from "node:path";
 import { Command } from "commander";
-import { hunchPaths, findRoot } from "../core/paths.js";
+import { hunchPaths, findRoot, toPosixTarget } from "../core/paths.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { selectEmbedder } from "../store/embedder.js";
 import { indexRepo } from "../extractors/indexer.js";
 import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesize.js";
 import { parseTestReport } from "../extractors/testreport.js";
 import { selectProvider } from "../synthesis/provider.js";
-import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff } from "../extractors/git.js";
+import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, revExists } from "../extractors/git.js";
 import { analyzeDiff } from "../extractors/diff.js";
 import { isStrictBlocker } from "../core/strictgate.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
@@ -55,7 +55,7 @@ function storeFor() {
 // ---- init -----------------------------------------------------------------
 program
     .command("init")
-    .description("Scaffold .hunch/, index the repo, install the git hook, and wire up Claude Code.")
+    .description("Scaffold .hunch/, index the repo, install the git hook, and wire up your coding assistants (Claude Code, Cursor, VS Code, Windsurf, Codex).")
     .option("--no-index", "skip the initial repo index")
     .option("--no-enforce", "do not install the advisory pre-commit constraint guard")
     .option("--enforce-strict", "make the pre-commit guard FAIL the commit on a direct, high-confidence, non-stale blocking invariant")
@@ -133,7 +133,7 @@ program
                 console.log(`  ⚠ skipped ${p.assistant}: ${p.error}`);
     }
     store.close();
-    console.log("\nNext: make a commit (the hook captures a decision), then ask Claude Code \"why is X built this way?\"");
+    console.log("\nNext: make a commit (the hook captures a decision), then ask your coding assistant \"why is X built this way?\"");
     console.log("Cold start? Seed from history:  hunch backfill --since 90d");
 });
 // ---- index ----------------------------------------------------------------
@@ -409,7 +409,7 @@ program
         return fail(`--severity must be one of: ${SEV.join(", ")}`);
     const { store, root } = storeFor();
     store.json.ensureDirs();
-    const scope = opts.scope.split(",").map((s) => s.trim()).filter(Boolean);
+    const scope = opts.scope.split(",").map((s) => toPosixTarget(s.trim())).filter(Boolean);
     const c = store.json.put("constraints", {
         id: constraintId(statement),
         type: opts.type,
@@ -550,6 +550,12 @@ program
     const markdown = opts.format === "markdown";
     const emptyReport = { fileCount: 0, strict: !!opts.strict, direct: [], near: [], regressions: [], strictBlockers: 0, regBlocking: 0 };
     const { store, root } = storeFor();
+    // Fail loudly on an unresolvable --base (e.g. CI forgot to fetch the base
+    // branch) — otherwise the diff is empty and the guard passes vacuously.
+    if (opts.base && !revExists(opts.base, root)) {
+        store.close();
+        return fail(`--base ref "${opts.base}" does not resolve. In CI, fetch the base branch first (git fetch origin <branch>).`);
+    }
     store.reindex(); // blast radius walks the edge graph — make the index current
     const files = opts.commit ? commitFiles(opts.commit, root)
         : opts.base ? rangeFiles(opts.base, root)
@@ -593,7 +599,7 @@ program
         return {
             id: c.id, severity: c.severity ?? "advisory", statement: c.statement, rationale: c.rationale ?? "",
             files: fs, strictBlocks,
-            downgrade: (c.severity === "blocking" && !strictBlocks ? (stale ? "stale" : "low-confidence") : undefined),
+            downgrade: c.severity === "blocking" && !strictBlocks ? (stale ? "stale" : "low-confidence") : undefined,
         };
     });
     const report = {

package/dist/cli/invocation.js

@@ -1,20 +1,37 @@
 /** Figures out how to re-invoke this CLI from a git hook / .mcp.json, working
  *  both when running the built dist (plain node) and in dev via tsx. */
 import { fileURLToPath } from "node:url";
+/** Published package name — used for OS-agnostic invocations (see below). */
+const PKG = "@davesheffer/hunch";
 export function resolveInvocation() {
     const entry = fileURLToPath(import.meta.url).replace(/invocation\.(js|ts)$/, "index.$1");
     const isDev = entry.endsWith(".ts");
     // JSON.stringify yields a double-quoted, backslash-escaped token /bin/sh
     // accepts — so install paths with spaces don't break the hook command.
     const q = (s) => JSON.stringify(s);
+    // Running from an installed copy (global, local, or npx cache — i.e. NOT a
+    // source checkout we're hacking on). The MCP/provider config files we write
+    // are committed and shared across a team via git, so they must NOT embed this
+    // machine's absolute path or OS-specific separators. Reference Hunch by its
+    // published package name instead, which `npx` resolves the same on any OS and
+    // any clone. The git hook lives in per-machine .git/hooks (never committed),
+    // so it keeps the PATH-robust absolute-node invocation below.
+    const installed = !isDev && entry.replace(/\\/g, "/").includes("/node_modules/");
+    if (installed) {
+        return {
+            shell: `${q(process.execPath)} ${q(entry)}`,
+            mcp: { command: "npx", args: ["-y", PKG] },
+        };
+    }
     if (isDev) {
         return {
             shell: `npx tsx ${q(entry)}`,
             mcp: { command: "npx", args: ["tsx", entry] },
         };
     }
-    // Use the absolute node binary (process.execPath) rather than a bare `node`,
-    // so the hook works even when nvm's `node` isn't on the hook's PATH.
+    // Source-checkout dist run (e.g. `node dist/cli/index.js`, npm link): inherently
+    // per-machine. Use the absolute node binary (process.execPath) rather than a bare
+    // `node`, so the hook works even when nvm's `node` isn't on the hook's PATH.
     return {
         shell: `${q(process.execPath)} ${q(entry)}`,
         mcp: { command: process.execPath, args: [entry] },

package/dist/core/paths.js

@@ -3,6 +3,14 @@ import { join } from "node:path";
 import { existsSync, statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 export const HUNCH_DIR = ".hunch";
+/** Canonicalize a free-form path/target to repo-relative POSIX form. Hunch stores
+ *  every path with forward slashes (git emits "/" on all OSes), so any user- or
+ *  agent-supplied target must be normalized before comparison — otherwise a
+ *  Windows caller passing `src\auth\session.ts` never matches the stored
+ *  `src/auth/session.ts`. Safe on symbol names too: they contain no backslashes. */
+export function toPosixTarget(target) {
+    return target.replace(/\\/g, "/").replace(/^\.\//, "");
+}
 export function hunchPaths(root) {
     const hunch = join(root, HUNCH_DIR);
     return {

package/dist/extractors/git.js

@@ -153,6 +153,12 @@ export function stagedFiles(cwd) {
     const out = gitSafe(["diff", "--cached", "--name-only", "--diff-filter=ACMR"], cwd);
     return out ? out.split("\n").filter(Boolean) : [];
 }
+/** Does a ref resolve to a commit in this repo? Lets `--base` fail LOUDLY on an
+ *  unfetched/typo'd ref instead of silently diffing against nothing (a vacuous
+ *  CI pass), since the diff helpers below swallow git errors to "". */
+export function revExists(ref, cwd) {
+    return gitSafe(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd) !== "";
+}
 /** Files a PR/branch changes vs `base` (3-dot: changes on HEAD since the merge-base,
  *  i.e. exactly the PR's own commits — the CI Constraint Guard's surface). */
 export function rangeFiles(base, cwd, head = "HEAD") {

package/dist/integrations/ciAction.js

@@ -38,6 +38,12 @@ jobs:
       - name: Install Hunch
         run: npm install -g @davesheffer/hunch
 
+      - name: Fetch the PR base branch
+        # checkout sets up no origin/<base> tracking ref; create it explicitly so
+        # the guard's base...head diff resolves (otherwise it sees zero changes and
+        # passes vacuously).
+        run: git fetch --no-tags origin "+refs/heads/\${{ github.base_ref }}:refs/remotes/origin/\${{ github.base_ref }}"
+
       - name: Run Constraint Guard
         id: guard
         run: |
@@ -52,19 +58,26 @@ jobs:
         with:
           script: |
             const fs = require('fs');
-            const body = fs.readFileSync('hunch-report.md', 'utf8').trim();
+            const body = (fs.existsSync('hunch-report.md') ? fs.readFileSync('hunch-report.md', 'utf8') : '').trim();
+            if (!body) { core.info('Hunch: empty report — skipping comment.'); return; }
             const marker = '<!-- hunch-guard -->';
             const { owner, repo } = context.repo;
             const issue_number = context.payload.pull_request.number;
-            const all = await github.paginate(github.rest.issues.listComments, { owner, repo, issue_number });
-            const existing = all.find(c => c.body && c.body.includes(marker));
             const out = marker + '\\n' + body;
-            if (existing) await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body: out });
-            else await github.rest.issues.createComment({ owner, repo, issue_number, body: out });
+            try {
+              const all = await github.paginate(github.rest.issues.listComments, { owner, repo, issue_number });
+              const existing = all.find(c => c.body && c.body.includes(marker));
+              if (existing) await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body: out });
+              else await github.rest.issues.createComment({ owner, repo, issue_number, body: out });
+            } catch (e) {
+              core.warning('Hunch: could not post PR comment (fork PR has a read-only token?): ' + e.message);
+            }
 
       - name: Enforce (fail on a blocking invariant)
+        # Default to 1 if the guard step died before recording its exit — never a
+        # vacuous pass.
         if: always()
-        run: exit \${{ steps.guard.outputs.exit }}
+        run: exit \${{ steps.guard.outputs.exit || '1' }}
 `;
 }
 /** Write .github/workflows/hunch-guard.yml. Never overwrites an existing file

package/dist/integrations/scaffold.js

@@ -22,38 +22,38 @@ export function writeMcpJson(root, inv) {
     writeFileSync(file, JSON.stringify(json, null, 2) + "\n");
     return file;
 }
-const WHY_CMD = `---
-description: Explain why a file or symbol is the way it is, from Hunch
----
-Use the \`hunch_why\` MCP tool on **$ARGUMENTS** (a file path or symbol name).
-
-Then summarize, with citations:
-- the **decisions** that shaped it (id + rationale),
-- the **constraints** that must not break,
-- the **bug history** behind it (root causes).
-
-Cite record ids and their provenance/confidence. If Hunch returns nothing,
-say so plainly and suggest running \`hunch index\` or \`hunch backfill\`.
+const WHY_CMD = `---
+description: Explain why a file or symbol is the way it is, from Hunch
+---
+Use the \`hunch_why\` MCP tool on **$ARGUMENTS** (a file path or symbol name).
+
+Then summarize, with citations:
+- the **decisions** that shaped it (id + rationale),
+- the **constraints** that must not break,
+- the **bug history** behind it (root causes).
+
+Cite record ids and their provenance/confidence. If Hunch returns nothing,
+say so plainly and suggest running \`hunch index\` or \`hunch backfill\`.
 `;
-const FIX_CMD = `---
-description: Fix a bug grounded in Hunch (past root causes, constraints, blast radius)
----
-We are fixing: **$ARGUMENTS**
-
-Follow the Hunch-grounded workflow (DESIGN §5) — do NOT skip the memory lookups:
-1. \`hunch_bug_lineage("$ARGUMENTS")\` — has this class of bug happened before? what was the root cause and the fix?
-2. Identify the suspect symbol/file, then \`hunch_get_dependents(<symbol>)\` to learn the blast radius.
-3. \`hunch_check_constraints(<scope>)\` — list invariants you must preserve.
-4. Propose a fix that honors past root causes AND constraints. Apply it and run the tests.
-5. If the fix encodes a non-trivial choice, \`hunch_record_decision(...)\` so the next session is grounded in it.
+const FIX_CMD = `---
+description: Fix a bug grounded in Hunch (past root causes, constraints, blast radius)
+---
+We are fixing: **$ARGUMENTS**
+
+Follow the Hunch-grounded workflow (DESIGN §5) — do NOT skip the memory lookups:
+1. \`hunch_bug_lineage("$ARGUMENTS")\` — has this class of bug happened before? what was the root cause and the fix?
+2. Identify the suspect symbol/file, then \`hunch_get_dependents(<symbol>)\` to learn the blast radius.
+3. \`hunch_check_constraints(<scope>)\` — list invariants you must preserve.
+4. Propose a fix that honors past root causes AND constraints. Apply it and run the tests.
+5. If the fix encodes a non-trivial choice, \`hunch_record_decision(...)\` so the next session is grounded in it.
 `;
-const FRAGILE_CMD = `---
-description: Report the most fragile parts of this codebase, with evidence
----
-Ask Hunch for the fragility ranking (run \`hunch fragile\` or query Hunch),
-then produce a **fragility report with evidence**: the specific files/functions,
-the bug history behind them, their churn and fan-in, and any missing guards.
-Avoid generic advice — every claim must cite a Hunch record or metric.
+const FRAGILE_CMD = `---
+description: Report the most fragile parts of this codebase, with evidence
+---
+Ask Hunch for the fragility ranking (run \`hunch fragile\` or query Hunch),
+then produce a **fragility report with evidence**: the specific files/functions,
+the bug history behind them, their churn and fan-in, and any missing guards.
+Avoid generic advice — every claim must cite a Hunch record or metric.
 `;
 /** A settings.json hook entry is Hunch's if any of its commands ends with the
  *  Hunch CLI entry + the `hook` subcommand (e.g. `…/index.js hook`). Matching the

package/dist/mcp/server.js

@@ -9,7 +9,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { hunchPaths, findRoot } from "../core/paths.js";
+import { hunchPaths, findRoot, toPosixTarget } from "../core/paths.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { selectEmbedder } from "../store/embedder.js";
 import { decisionId } from "../core/ids.js";
@@ -29,6 +29,7 @@ const SEV_BUG = { critical: 4, high: 3, medium: 2, low: 1 };
 const more = (total, cap, hint = "") => total > cap ? `\n  …(+${total - cap} more${hint ? ` — ${hint}` : ""})` : "";
 /** Resolve a free-form target (symbol id / name / file path) to symbol records. */
 function resolveSymbols(store, target) {
+    target = toPosixTarget(target);
     const syms = store.json.loadAll("symbols");
     const byId = syms.find((s) => s.id === target);
     if (byId)
@@ -42,7 +43,7 @@ function resolveSymbols(store, target) {
  *  radius). Falls back to the literal target so direct-scope checks still run. */
 function resolveFiles(store, target) {
     const files = new Set(resolveSymbols(store, target).map((s) => s.file));
-    return files.size ? [...files] : [target];
+    return files.size ? [...files] : [toPosixTarget(target)];
 }
 export function buildServer(root) {
     const store = new HunchStore(hunchPaths(root));
@@ -261,7 +262,7 @@ export function buildServer(root) {
                 consequences: decision.consequences ?? [],
                 alternatives_rejected: decision.alternatives_rejected ?? [],
                 related_components: decision.related_components ?? existing?.related_components ?? [],
-                related_files: decision.related_files ?? existing?.related_files ?? [],
+                related_files: (decision.related_files ?? existing?.related_files ?? []).map(toPosixTarget),
                 supersedes: decision.supersedes ?? existing?.supersedes ?? null,
                 superseded_by: existing?.superseded_by ?? null,
                 caused_by_bug: existing?.caused_by_bug ?? null,
@@ -269,7 +270,7 @@ export function buildServer(root) {
                 valid_from: existing?.valid_from ?? now,
                 valid_to: existing?.valid_to ?? null,
                 retired: existing?.retired ?? { symbols: [], deps: [] },
-                provenance: { source, confidence: 0.95, evidence: decision.related_files ?? existing?.provenance.evidence ?? [] },
+                provenance: { source, confidence: 0.95, evidence: (decision.related_files ?? existing?.provenance.evidence ?? []).map(toPosixTarget) },
                 date: now,
             };
             store.json.put("decisions", rec);

package/dist/store/hunchStore.js

@@ -1,3 +1,16 @@
+/**
+ * HunchStore — the read/write query layer over the JSON source of truth and the
+ * SQLite derived index. Everything the CLI and MCP server need flows through here.
+ *
+ *   - reindex():        JSON  -> SQLite (rebuild the derived index + FTS)
+ *   - search():         FTS5 ranked query (hunch_query)
+ *   - why():            decisions/bugs/constraints explaining a path/symbol
+ *   - getDependents():  recursive-CTE blast radius over the call/dep graph
+ *   - checkConstraints(): constraints whose scope matches a glob/path
+ *   - bugLineage():     bugs matching a symptom/symbol + their lineage
+ *   - fragility():      ranked fragility report with evidence
+ */
+import { toPosixTarget } from "../core/paths.js";
 import { ENTITY_KINDS } from "../core/types.js";
 import { openDb } from "./db.js";
 import { RESET_SQL, embedHash } from "./schema.js";
@@ -112,7 +125,7 @@ export class HunchStore {
         if (!match)
             return this.likeSearch(query, limit);
         try {
-            const rows = this.db.prepare(`SELECT ref, kind, title, snippet(search, 3, '[', ']', '…', 12) AS snip, bm25(search) AS score
+            const rows = this.db.prepare(`SELECT ref, kind, title, snippet(search, 3, '[', ']', '…', 12) AS snip, bm25(search) AS score
          FROM search WHERE search MATCH ? ORDER BY score LIMIT ?`).all(match, limit);
             return rows.map((r) => ({ ref: r.ref, kind: r.kind, title: r.title, snippet: r.snip, score: r.score }));
         }
@@ -124,7 +137,7 @@ export class HunchStore {
     /** Substring fallback over titles/bodies (handles non-ASCII / malformed FTS). */
     likeSearch(query, limit) {
         const like = `%${query.replace(/[%_]/g, "")}%`;
-        const rows = this.db.prepare(`SELECT ref, kind, title, substr(body,1,120) AS snip FROM search
+        const rows = this.db.prepare(`SELECT ref, kind, title, substr(body,1,120) AS snip FROM search
        WHERE title LIKE ? OR body LIKE ? LIMIT ?`).all(like, like, limit);
         return rows.map((r) => ({ ref: r.ref, kind: r.kind, title: r.title, snippet: r.snip, score: 0 }));
     }
@@ -281,6 +294,7 @@ export class HunchStore {
      *  instant — "what did we believe as of commit X?". Omit `asOf` for the full,
      *  history-inclusive view (backward-compatible default). */
     why(target, opts = {}) {
+        target = toPosixTarget(target);
         const decisions = this.json.loadAll("decisions");
         const bugs = this.json.loadAll("bugs");
         const constraints = this.json.loadAll("constraints");
@@ -308,37 +322,37 @@ export class HunchStore {
      *  walk edges BACKWARD (edges.to = current) following call/dep/import/contains. */
     getDependents(id, maxDepth = 6) {
         return this.db.prepare(
-        /* sql */ `
-      WITH RECURSIVE up(node, depth) AS (
-        SELECT ?, 0
-        UNION
-        SELECT e."from", up.depth + 1
-        FROM edges e JOIN up ON e."to" = up.node
-        WHERE e.type IN ('calls','depends_on','imports','contains') AND up.depth < ?
-      )
-      SELECT up.node AS id, MIN(up.depth) AS depth,
-             COALESCE(s.name || ' @ ' || s.file, c.name, up.node) AS via
-      FROM up
-      LEFT JOIN symbols s ON s.id = up.node
-      LEFT JOIN components c ON c.id = up.node
+        /* sql */ `
+      WITH RECURSIVE up(node, depth) AS (
+        SELECT ?, 0
+        UNION
+        SELECT e."from", up.depth + 1
+        FROM edges e JOIN up ON e."to" = up.node
+        WHERE e.type IN ('calls','depends_on','imports','contains') AND up.depth < ?
+      )
+      SELECT up.node AS id, MIN(up.depth) AS depth,
+             COALESCE(s.name || ' @ ' || s.file, c.name, up.node) AS via
+      FROM up
+      LEFT JOIN symbols s ON s.id = up.node
+      LEFT JOIN components c ON c.id = up.node
       WHERE up.node <> ? GROUP BY up.node ORDER BY depth, id`).all(id, maxDepth, id);
     }
     /** Symbols/components this id depends ON (forward walk) — used for refactor blast radius. */
     getDependencies(id, maxDepth = 6) {
         return this.db.prepare(
-        /* sql */ `
-      WITH RECURSIVE down(node, depth) AS (
-        SELECT ?, 0
-        UNION
-        SELECT e."to", down.depth + 1
-        FROM edges e JOIN down ON e."from" = down.node
-        WHERE e.type IN ('calls','depends_on','imports','contains') AND down.depth < ?
-      )
-      SELECT down.node AS id, MIN(down.depth) AS depth,
-             COALESCE(s.name || ' @ ' || s.file, c.name, down.node) AS via
-      FROM down
-      LEFT JOIN symbols s ON s.id = down.node
-      LEFT JOIN components c ON c.id = down.node
+        /* sql */ `
+      WITH RECURSIVE down(node, depth) AS (
+        SELECT ?, 0
+        UNION
+        SELECT e."to", down.depth + 1
+        FROM edges e JOIN down ON e."from" = down.node
+        WHERE e.type IN ('calls','depends_on','imports','contains') AND down.depth < ?
+      )
+      SELECT down.node AS id, MIN(down.depth) AS depth,
+             COALESCE(s.name || ' @ ' || s.file, c.name, down.node) AS via
+      FROM down
+      LEFT JOIN symbols s ON s.id = down.node
+      LEFT JOIN components c ON c.id = down.node
       WHERE down.node <> ? GROUP BY down.node ORDER BY depth, id`).all(id, maxDepth, id);
     }
     /** Files whose symbols (in)directly DEPEND ON a symbol defined in `file` — the
@@ -350,17 +364,17 @@ export class HunchStore {
         // the bare `via` take the name from the nearest-depth row. The inner JOIN drops
         // non-symbol nodes; `s.file <> ?` drops self-file dependents.
         return this.db.prepare(
-        /* sql */ `
-      WITH RECURSIVE up(node, depth) AS (
-        SELECT id, 0 FROM symbols WHERE file = ?
-        UNION
-        SELECT e."from", up.depth + 1
-        FROM edges e JOIN up ON e."to" = up.node
-        WHERE e.type IN ('calls','depends_on','imports','contains') AND up.depth < ?
-      )
-      SELECT s.file AS file, s.name AS via, MIN(up.depth) AS depth
-      FROM up JOIN symbols s ON s.id = up.node
-      WHERE up.depth > 0 AND s.file <> ?
+        /* sql */ `
+      WITH RECURSIVE up(node, depth) AS (
+        SELECT id, 0 FROM symbols WHERE file = ?
+        UNION
+        SELECT e."from", up.depth + 1
+        FROM edges e JOIN up ON e."to" = up.node
+        WHERE e.type IN ('calls','depends_on','imports','contains') AND up.depth < ?
+      )
+      SELECT s.file AS file, s.name AS via, MIN(up.depth) AS depth
+      FROM up JOIN symbols s ON s.id = up.node
+      WHERE up.depth > 0 AND s.file <> ?
       GROUP BY s.file ORDER BY depth, file`).all(file, maxDepth, file);
     }
     /** Constraints whose scope glob matches a path/glob (hunch_check_constraints).
@@ -558,6 +572,7 @@ export class HunchStore {
      *  a task on `target`, ordered by what matters most — invariants first, then the
      *  why, then blast radius and bug history — trimmed to a rough token budget. */
     assembleContext(target, budget = 1500, opts = {}) {
+        target = toPosixTarget(target);
         const w = this.why(target, opts);
         const symIds = w.symbols.map((s) => s.id);
         const blast = new Map();

package/dist/store/schema.js

@@ -15,87 +15,87 @@ import { shortHash } from "../core/ids.js";
 export function embedHash(title, body) {
     return shortHash(`${title}\x00${body ?? ""}`, 16);
 }
-export const SCHEMA_SQL = /* sql */ `
-PRAGMA journal_mode = WAL;
-PRAGMA foreign_keys = OFF;
-
-CREATE TABLE IF NOT EXISTS components (
-  id TEXT PRIMARY KEY,
-  kind TEXT, name TEXT, responsibility TEXT,
-  paths TEXT, status TEXT, owners TEXT,
-  fragility REAL,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
-  created_at TEXT, updated_at TEXT
-);
-
-CREATE TABLE IF NOT EXISTS edges (
-  id TEXT PRIMARY KEY,
-  "from" TEXT, "to" TEXT, type TEXT, reason TEXT, strength REAL,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_edges_from ON edges("from");
-CREATE INDEX IF NOT EXISTS idx_edges_to ON edges("to");
-CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
-
-CREATE TABLE IF NOT EXISTS symbols (
-  id TEXT PRIMARY KEY,
-  file TEXT, name TEXT, kind TEXT, signature_hash TEXT,
-  calls TEXT, called_by TEXT,
-  loc INTEGER, churn_90d INTEGER, bug_count INTEGER, fan_in INTEGER, fan_out INTEGER,
-  last_changed TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
-CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-
-CREATE TABLE IF NOT EXISTS decisions (
-  id TEXT PRIMARY KEY,
-  title TEXT, status TEXT, context TEXT, decision TEXT,
-  consequences TEXT, alternatives_rejected TEXT,
-  related_components TEXT, related_files TEXT,
-  supersedes TEXT, caused_by_bug TEXT, "commit" TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
-  date TEXT
-);
-
-CREATE TABLE IF NOT EXISTS bugs (
-  id TEXT PRIMARY KEY,
-  title TEXT, symptom TEXT, root_cause TEXT, severity TEXT, status TEXT,
-  affected_files TEXT, affected_symbols TEXT, lineage TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-
-CREATE TABLE IF NOT EXISTS constraints (
-  id TEXT PRIMARY KEY,
-  type TEXT, statement TEXT, scope TEXT, severity TEXT, enforcement TEXT,
-  rationale TEXT, source_decision TEXT, violations TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-
--- Unified full-text search across every entity. Rebuilt on index; bm25-ranked.
-CREATE VIRTUAL TABLE IF NOT EXISTS search USING fts5(
-  ref UNINDEXED,   -- entity id
-  kind UNINDEXED,  -- components | edges | symbols | decisions | bugs | constraints
-  title,
-  body,
-  tokenize = 'porter unicode61'
-);
-
--- Local semantic-search vectors (opt-in; written by \`hunch embed\`). One row per
--- (ref, model); vec is a Float32 BLOB. DELIBERATELY NOT in RESET_SQL: reindex()
--- runs RESET on nearly every path (MCP startup, every query/context), so resetting
--- embeddings here would wipe them constantly and make the feature a no-op. Staleness
--- is tracked by doc_hash and reconciled by pruneStaleEmbeddings() instead. Recall is
--- exact brute-force cosine in JS (graphs are small); sqlite-vec only past ~100k rows.
-CREATE TABLE IF NOT EXISTS embeddings (
-  ref TEXT, kind TEXT, model TEXT, dim INTEGER, doc_hash TEXT, vec BLOB,
-  PRIMARY KEY (ref, model)
-);
+export const SCHEMA_SQL = /* sql */ `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = OFF;
+
+CREATE TABLE IF NOT EXISTS components (
+  id TEXT PRIMARY KEY,
+  kind TEXT, name TEXT, responsibility TEXT,
+  paths TEXT, status TEXT, owners TEXT,
+  fragility REAL,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
+  created_at TEXT, updated_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  "from" TEXT, "to" TEXT, type TEXT, reason TEXT, strength REAL,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_edges_from ON edges("from");
+CREATE INDEX IF NOT EXISTS idx_edges_to ON edges("to");
+CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id TEXT PRIMARY KEY,
+  file TEXT, name TEXT, kind TEXT, signature_hash TEXT,
+  calls TEXT, called_by TEXT,
+  loc INTEGER, churn_90d INTEGER, bug_count INTEGER, fan_in INTEGER, fan_out INTEGER,
+  last_changed TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+
+CREATE TABLE IF NOT EXISTS decisions (
+  id TEXT PRIMARY KEY,
+  title TEXT, status TEXT, context TEXT, decision TEXT,
+  consequences TEXT, alternatives_rejected TEXT,
+  related_components TEXT, related_files TEXT,
+  supersedes TEXT, caused_by_bug TEXT, "commit" TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
+  date TEXT
+);
+
+CREATE TABLE IF NOT EXISTS bugs (
+  id TEXT PRIMARY KEY,
+  title TEXT, symptom TEXT, root_cause TEXT, severity TEXT, status TEXT,
+  affected_files TEXT, affected_symbols TEXT, lineage TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+
+CREATE TABLE IF NOT EXISTS constraints (
+  id TEXT PRIMARY KEY,
+  type TEXT, statement TEXT, scope TEXT, severity TEXT, enforcement TEXT,
+  rationale TEXT, source_decision TEXT, violations TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+
+-- Unified full-text search across every entity. Rebuilt on index; bm25-ranked.
+CREATE VIRTUAL TABLE IF NOT EXISTS search USING fts5(
+  ref UNINDEXED,   -- entity id
+  kind UNINDEXED,  -- components | edges | symbols | decisions | bugs | constraints
+  title,
+  body,
+  tokenize = 'porter unicode61'
+);
+
+-- Local semantic-search vectors (opt-in; written by \`hunch embed\`). One row per
+-- (ref, model); vec is a Float32 BLOB. DELIBERATELY NOT in RESET_SQL: reindex()
+-- runs RESET on nearly every path (MCP startup, every query/context), so resetting
+-- embeddings here would wipe them constantly and make the feature a no-op. Staleness
+-- is tracked by doc_hash and reconciled by pruneStaleEmbeddings() instead. Recall is
+-- exact brute-force cosine in JS (graphs are small); sqlite-vec only past ~100k rows.
+CREATE TABLE IF NOT EXISTS embeddings (
+  ref TEXT, kind TEXT, model TEXT, dim INTEGER, doc_hash TEXT, vec BLOB,
+  PRIMARY KEY (ref, model)
+);
 `;
 /** Drop derived data (used before a full reindex). NOTE: embeddings is omitted on
  *  purpose — see the embeddings table comment above. */
-export const RESET_SQL = /* sql */ `
-DELETE FROM components; DELETE FROM edges; DELETE FROM symbols;
-DELETE FROM decisions; DELETE FROM bugs; DELETE FROM constraints;
-DELETE FROM search;
+export const RESET_SQL = /* sql */ `
+DELETE FROM components; DELETE FROM edges; DELETE FROM symbols;
+DELETE FROM decisions; DELETE FROM bugs; DELETE FROM constraints;
+DELETE FROM search;
 `;
 //# sourceMappingURL=schema.js.map

package/dist/synthesis/provider.js

@@ -96,10 +96,10 @@ export function pexecIn(cmd, args, opts = {}) {
         child.stdin.end();
     });
 }
-const SYSTEM = `You are the synthesis engine of an Engineering Memory OS. You turn raw
-developer activity (a git commit diff, or a test failure) into a single structured
-"why" record. Be precise and evidence-grounded; never invent facts not supported by
-the input. Prefer short, concrete statements. If intent is unclear, say so plainly
+const SYSTEM = `You are the synthesis engine of an Engineering Memory OS. You turn raw
+developer activity (a git commit diff, or a test failure) into a single structured
+"why" record. Be precise and evidence-grounded; never invent facts not supported by
+the input. Prefer short, concrete statements. If intent is unclear, say so plainly
 rather than guessing.`;
 const DECISION_TOOL = {
     name: "emit_decision",