@esneiderbravo/speclaw 0.3.9 → 0.3.10

package/dist/cli/commands/query.js

@@ -1,15 +1,19 @@
 import { explore, search, recall, impact, trace } from "../../modules/compass/query.js";
+import { affectedTests } from "../../modules/compass/affected.js";
+import { list } from "../lib/args.js";
 import { ui } from "../lib/ui.js";
 /**
  * Run a Compass query from the shell — the same surface agents call via MCP.
  *
- * @param cmd - The query verb: `explore`, `search`, `recall`, `impact`, or `trace`.
- * @param flags - Parsed flags supplying the positional query arguments in `_`.
+ * @param cmd - Query verb: `explore`, `search`, `recall`, `impact`, `trace`, or
+ *   `affected-tests`.
+ * @param flags - Parsed flags supplying positional args and options in `_`.
  * @throws Exits the process with code 1 on missing arguments or query errors.
  */
 export async function runQuery(cmd, flags) {
     const cwd = process.cwd();
     const args = flags._;
+    const asJson = Boolean(flags.json);
     try {
         switch (cmd) {
             case "explore": {
@@ -41,9 +45,73 @@ export async function runQuery(cmd, flags) {
                 return;
             }
             case "impact": {
-                const nodes = impact(cwd, need(args[0], "impact <node>"));
-                ui.heading(`Blast radius: ${nodes.length} dependent(s)`);
-                nodes.forEach((n) => ui.info(`depth ${n.depth}: ${n.name} (${n.file}:${n.line})`));
+                const fileList = list(flags.file);
+                if (!args[0] && fileList.length === 0) {
+                    need(undefined, "impact <node> | impact --file <path>");
+                }
+                const format = flags.flat ? "flat" : "grouped";
+                const result = impact(cwd, {
+                    symbol: args[0],
+                    files: fileList.length ? fileList : undefined,
+                    maxDepth: flags.depth ? Number(flags.depth) : 4,
+                    format,
+                    target: typeof flags.target === "string" ? flags.target : "any",
+                });
+                if (asJson) {
+                    console.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                if (result.global) {
+                    ui.heading(`Blast radius: repo-wide`);
+                    ui.warn(result.global.reason);
+                    result.warnings.forEach((w) => ui.warn(w));
+                    return;
+                }
+                ui.heading(`Blast radius: ${result.totals.nodes} node(s) in ${result.totals.modules} module(s)` +
+                    (result.limits.truncated ? " (truncated)" : ""));
+                if (result.target.kind === "symbol" && result.target.definitions.length > 1) {
+                    ui.warn(`"${result.target.symbol}" is defined in ${result.target.definitions.length} places; impact is the union`);
+                }
+                if (format === "flat" && result.nodes) {
+                    result.nodes.forEach((n) => ui.info(`depth ${n.depth} [${n.resolution}]: ${n.name} (${n.file}:${n.line})`));
+                }
+                else {
+                    for (const m of result.modules) {
+                        ui.heading(`${m.module} — ${m.nodes} node(s), ${m.files} file(s), min depth ${m.minDepth}`);
+                        m.top.forEach((n) => ui.info(`depth ${n.depth} [${n.resolution}]: ${n.name} (${n.file}:${n.line})`));
+                    }
+                }
+                if (result.resolution.byName > 0) {
+                    ui.warn(`${result.resolution.byName} result(s) resolved by name (possible collisions)`);
+                }
+                result.warnings.forEach((w) => ui.warn(w));
+                return;
+            }
+            case "affected-tests": {
+                const files = list(flags.file);
+                const fromDiff = typeof flags["from-diff"] === "string"
+                    ? flags["from-diff"]
+                    : flags["from-diff"] === true
+                        ? "HEAD"
+                        : undefined;
+                if (files.length === 0 && !fromDiff && !args[0]) {
+                    need(undefined, "affected-tests --file <path> | --from-diff <ref>");
+                }
+                const result = affectedTests(cwd, {
+                    files: files.length ? files : undefined,
+                    symbols: args[0] ? [args[0]] : undefined,
+                    fromDiff,
+                });
+                if (asJson) {
+                    console.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                ui.heading(`Affected tests (${result.mode}): ${result.tests.length} file(s) — skipped ${result.skipped.files} (${result.skipped.percent}%)`);
+                ui.info(result.reason);
+                result.tests.forEach((t) => ui.info(t.file));
+                ui.heading("Command");
+                console.log(result.command);
+                result.warnings.forEach((w) => ui.warn(w));
                 return;
             }
             case "trace": {

package/dist/cli/commands/update.js

@@ -108,6 +108,15 @@ const MIGRATIONS = [
             "reindex with `speclaw index`, then `speclaw drift --reseal` once to photograph current bodies.\n" +
             "- Preserve all project-specific wording; only apply these speclaw-authored changes.",
     },
+    {
+        version: "0.3.10",
+        describe: "Impact v2 + affected-tests: schema 7, grouped blast radius",
+        agentPrompt: "- Mention `compass_impact` (grouped by default; `format: flat` escape hatch) and " +
+            "`compass_affected_tests` / `speclaw affected-tests --from-diff`. Compass schema is now 7 " +
+            "(`files.is_test`, `files.module`) — reindex with `speclaw index`. Optional " +
+            "`.speclaw/affected.json` overrides globals/test globs.\n" +
+            "- Preserve all project-specific wording; only apply these speclaw-authored changes.",
+    },
 ];
 /**
  * Update speclaw and bring the current project up to date without a full re-init:

package/dist/cli/index.js

@@ -23,7 +23,8 @@ Compass (code intelligence — the same surface agents use via MCP)
   explore <node>           A node's source + callers/callees
   search <query>           Find nodes by name/keyword
   recall "<query>"         Find code by meaning (semantic)
-  impact <node>            Blast radius: everything that (transitively) calls it
+  impact <node>            Blast radius (grouped by module; --flat / --json)
+  affected-tests           Tests affected by a change (--file / --from-diff / --json)
   trace <from> <to>        A call path between two nodes
   visualize [node]         Interactive HTML graph → .speclaw/graph.html
 
@@ -50,9 +51,9 @@ Other
 // Commands that open with the one-line branded header. These are the
 // interactive, human-facing commands whose stdout is prose. Deliberately
 // excluded: `version`/`--version`/`-v` (bare scriptable value), the Compass
-// query family (`explore`/`search`/`recall`/`impact`/`trace`, machine-consumed
-// output), `mcp` (a long-running stdio server), and `init` (already opens with
-// the fuller `banner()`).
+// query family (`explore`/`search`/`recall`/`impact`/`trace`/`affected-tests`,
+// machine-consumed output), `mcp` (a long-running stdio server), and `init`
+// (already opens with the fuller `banner()`).
 const HEADER_COMMANDS = new Set([
     undefined,
     "help",
@@ -126,6 +127,7 @@ async function dispatch(cmd, flags) {
         case "recall":
         case "impact":
         case "trace":
+        case "affected-tests":
             return (await import("./commands/query.js")).runQuery(cmd, flags);
         case "visualize":
             return (await import("./commands/visualize.js")).runVisualize(flags);

package/dist/modules/compass/affected-config.js

@@ -0,0 +1,238 @@
+/**
+ * Optional `.speclaw/affected.json` plus embedded defaults for global files,
+ * test globs, named targets, and ignores used by impact / affected-tests.
+ */
+import fs from "node:fs";
+import path from "node:path";
+const DEFAULT_TARGETS = {
+    build: {
+        include: ["src/**"],
+        exclude: ["**/*.{test,spec}.{ts,tsx,js,jsx,mts,cts}", "test/**", "tests/**"],
+    },
+    test: {
+        include: [
+            "src/**",
+            "test/**",
+            "tests/**",
+            "**/*.{test,spec}.{ts,tsx,js,jsx}",
+            "**/conftest.py",
+        ],
+        exclude: [],
+    },
+    lint: {
+        include: ["**/*.{ts,tsx,js,jsx,py}", ".eslintrc*", "eslint.config.*", "ruff.toml"],
+        exclude: [],
+    },
+};
+/** Embedded defaults when `.speclaw/affected.json` is absent. */
+export const DEFAULT_AFFECTED_CONFIG = {
+    version: 1,
+    globalFiles: [
+        "tsconfig*.json",
+        "package.json",
+        "package-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "LAWS.md",
+        "lawbook/config.yaml",
+        ".speclaw/rules.json",
+        "**/*.config.{ts,js,mjs,cjs}",
+    ],
+    testGlobs: [
+        "test/**",
+        "tests/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/conftest.py",
+        "**/test_*.py",
+    ],
+    targets: DEFAULT_TARGETS,
+    ignore: [
+        "node_modules/**",
+        "dist/**",
+        "dist-test/**",
+        "vendor/**",
+        "**/generated/**",
+        ".speclaw/**",
+    ],
+};
+/**
+ * Glob match supporting `**`, `*`, and simple `{a,b}` brace lists.
+ *
+ * @param relPath - Project-relative path (either slash style).
+ * @param pattern - Glob pattern.
+ */
+export function matchGlob(relPath, pattern) {
+    const norm = relPath.split("\\").join("/");
+    for (const expanded of expandBraces(pattern.split("\\").join("/"))) {
+        if (globToRegExp(expanded).test(norm))
+            return true;
+    }
+    return false;
+}
+function expandBraces(pattern) {
+    const m = pattern.match(/\{([^{}]+)\}/);
+    if (!m || m.index === undefined)
+        return [pattern];
+    const before = pattern.slice(0, m.index);
+    const after = pattern.slice(m.index + m[0].length);
+    const alts = m[1].split(",");
+    const out = [];
+    for (const alt of alts) {
+        out.push(...expandBraces(before + alt + after));
+    }
+    return out;
+}
+function globToRegExp(pattern) {
+    let i = 0;
+    let re = "^";
+    while (i < pattern.length) {
+        if (pattern.startsWith("**/", i) || (pattern.startsWith("**", i) && i + 2 === pattern.length)) {
+            re += ".*";
+            i += pattern.startsWith("**/", i) ? 3 : 2;
+            continue;
+        }
+        if (pattern[i] === "*") {
+            re += "[^/]*";
+            i++;
+            continue;
+        }
+        const ch = pattern[i];
+        if (/[.+^${}()|[\]\\]/.test(ch))
+            re += `\\${ch}`;
+        else
+            re += ch;
+        i++;
+    }
+    re += "$";
+    return new RegExp(re);
+}
+/**
+ * Whether a relative path matches any of the given globs.
+ *
+ * @param relPath - Project-relative path.
+ * @param globs - Patterns to try.
+ */
+export function matchesAny(relPath, globs) {
+    return globs.some((g) => matchGlob(relPath, g));
+}
+/**
+ * Infer the module bucket for grouping (nearest package root or first two path segments).
+ *
+ * @param relPath - Project-relative file path.
+ */
+export function inferModule(relPath) {
+    const norm = relPath.split("\\").join("/");
+    const parts = norm.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return ".";
+    if (parts.length === 1)
+        return parts[0];
+    // Prefer src/<area>, test/<area>, packages/<name>, …
+    return parts.slice(0, 2).join("/");
+}
+/**
+ * Whether a path looks like a test file under the given test globs.
+ *
+ * @param relPath - Project-relative path.
+ * @param testGlobs - Glob list (defaults from config).
+ */
+export function isTestPath(relPath, testGlobs = DEFAULT_AFFECTED_CONFIG.testGlobs) {
+    return matchesAny(relPath, testGlobs);
+}
+/**
+ * Load and validate `.speclaw/affected.json`, or return embedded defaults.
+ *
+ * @param projectPath - Absolute project root.
+ * @returns The effective config.
+ * @throws If the file exists but is malformed or has the wrong version shape.
+ */
+export function loadAffectedConfig(projectPath) {
+    const p = path.join(projectPath, ".speclaw", "affected.json");
+    if (!fs.existsSync(p))
+        return { ...DEFAULT_AFFECTED_CONFIG, targets: { ...DEFAULT_TARGETS } };
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch (err) {
+        throw new Error(`Invalid .speclaw/affected.json: ${err.message}`, { cause: err });
+    }
+    if (!raw || typeof raw !== "object") {
+        throw new Error("Invalid .speclaw/affected.json: expected a JSON object");
+    }
+    const doc = raw;
+    if (doc.version !== 1 && doc.version !== undefined) {
+        throw new Error(`Invalid .speclaw/affected.json: unsupported version ${String(doc.version)}`);
+    }
+    const cfg = {
+        version: 1,
+        globalFiles: asStringArray(doc.globalFiles, DEFAULT_AFFECTED_CONFIG.globalFiles),
+        testGlobs: asStringArray(doc.testGlobs, DEFAULT_AFFECTED_CONFIG.testGlobs),
+        ignore: asStringArray(doc.ignore, DEFAULT_AFFECTED_CONFIG.ignore),
+        targets: { ...DEFAULT_TARGETS },
+    };
+    if (doc.targets && typeof doc.targets === "object") {
+        const t = doc.targets;
+        for (const name of ["build", "test", "lint"]) {
+            const entry = t[name];
+            if (!entry || typeof entry !== "object")
+                continue;
+            const e = entry;
+            cfg.targets[name] = {
+                include: asStringArray(e.include, DEFAULT_TARGETS[name].include),
+                exclude: asStringArray(e.exclude, DEFAULT_TARGETS[name].exclude),
+            };
+        }
+    }
+    return cfg;
+}
+function asStringArray(value, fallback) {
+    if (!Array.isArray(value))
+        return [...fallback];
+    const out = value.filter((v) => typeof v === "string" && v.length > 0);
+    return out.length > 0 ? out : [...fallback];
+}
+/**
+ * Filter changed paths for a named target (Nx-style named inputs).
+ *
+ * @param files - Candidate relative paths.
+ * @param target - Target name; `any` keeps all non-ignored paths.
+ * @param cfg - Affected config.
+ */
+export function filterFilesForTarget(files, target, cfg) {
+    const warnings = [];
+    const notIgnored = files.filter((f) => !matchesAny(f, cfg.ignore));
+    if (target === "any")
+        return { included: notIgnored, warnings };
+    const spec = cfg.targets[target];
+    const included = notIgnored.filter((f) => {
+        if (spec.exclude.some((g) => matchGlob(f, g)))
+            return false;
+        return spec.include.some((g) => matchGlob(f, g));
+    });
+    if (included.length === 0 && notIgnored.length > 0) {
+        warnings.push(`Change only affects other targets; empty for target "${target}" (${notIgnored.length} path(s) filtered out)`);
+    }
+    return { included, warnings };
+}
+/**
+ * Match changed paths against globalFiles globs.
+ *
+ * @param files - Relative paths.
+ * @param cfg - Affected config.
+ */
+export function matchGlobalFiles(files, cfg) {
+    const patterns = new Set();
+    const matched = [];
+    for (const f of files) {
+        for (const g of cfg.globalFiles) {
+            if (matchGlob(f, g)) {
+                matched.push(f);
+                patterns.add(g);
+                break;
+            }
+        }
+    }
+    return { matched, patterns: [...patterns] };
+}

package/dist/modules/compass/affected.js

@@ -0,0 +1,249 @@
+/**
+ * Static affected-test selection: reverse reachability into `files.is_test = 1`,
+ * plus a ready-to-run command string.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { changedFiles, isGitRepo } from "../../shared/git.js";
+import { openDb, indexExists } from "./db.js";
+import { impact } from "./query.js";
+import { loadAffectedConfig, matchGlobalFiles, matchesAny, } from "./affected-config.js";
+/**
+ * Select a safe superset of test files affected by a change.
+ *
+ * @param projectPath - Absolute project root with a Compass index.
+ * @param query - Files, symbols, and/or a git diff base ref.
+ */
+export function affectedTests(projectPath, query = {}) {
+    if (!indexExists(projectPath)) {
+        throw new Error("No index found. Build it first with the index_build tool (creates .speclaw/index.db).");
+    }
+    const cfg = loadAffectedConfig(projectPath);
+    const warnings = [];
+    warnings.push(...warnUnindexedLanguages(projectPath));
+    let files = [...(query.files ?? [])];
+    if (query.fromDiff !== undefined) {
+        if (!isGitRepo(projectPath)) {
+            throw new Error("fromDiff requires a git repository");
+        }
+        const base = query.fromDiff === "WORKTREE" || query.fromDiff === "" ? "HEAD" : query.fromDiff;
+        // WORKTREE ≈ uncommitted: use merge-base against HEAD's first-parent via changedFiles("HEAD")
+        // when the caller passes a branch/ref; for literal WORKTREE fall back to HEAD...working tree
+        // is not in changedFiles — use the ref as merge-base target.
+        const diffFiles = query.fromDiff === "WORKTREE"
+            ? listWorktreeChanges(projectPath)
+            : changedFiles(projectPath, base);
+        files = [...new Set([...files, ...diffFiles])];
+        if (files.length === 0) {
+            return {
+                mode: "static",
+                reason: "no changed files",
+                tests: [],
+                skipped: { files: countTestFiles(projectPath), percent: 100 },
+                command: buildTestCommand(projectPath, [], cfg, "none"),
+                warnings,
+            };
+        }
+    }
+    const glob = matchGlobalFiles(files, cfg);
+    if (glob.matched.length > 0) {
+        const allTests = listTestFiles(projectPath);
+        return {
+            mode: "all",
+            reason: `global file matched (${glob.matched.join(", ")})`,
+            tests: allTests.map((file) => ({ file, nodes: 0, minDepth: 0 })),
+            skipped: { files: 0, percent: 0 },
+            command: buildTestCommand(projectPath, [], cfg, "all"),
+            warnings,
+        };
+    }
+    const impactOpts = {
+        files: files.length > 0 ? files : undefined,
+        symbol: query.symbols?.length === 1 ? query.symbols[0] : undefined,
+        maxDepth: query.maxDepth ?? 6,
+        format: "flat",
+        target: "test",
+        edgeKinds: ["call", "import"],
+    };
+    // Multiple symbols → union flat impacts.
+    const nodes = [...(impact(projectPath, impactOpts).nodes ?? [])];
+    if (query.symbols && query.symbols.length > 1) {
+        const seen = new Set(nodes.map((n) => n.nodeId));
+        for (const sym of query.symbols) {
+            for (const n of impact(projectPath, {
+                symbol: sym,
+                format: "flat",
+                maxDepth: impactOpts.maxDepth,
+            }).nodes ?? []) {
+                if (!seen.has(n.nodeId)) {
+                    seen.add(n.nodeId);
+                    nodes.push(n);
+                }
+            }
+        }
+    }
+    // Also include directly changed test files.
+    const testHits = new Map();
+    for (const f of files) {
+        const norm = f.split("\\").join("/");
+        if (matchesAny(norm, cfg.testGlobs)) {
+            testHits.set(norm, { file: norm, nodes: 0, minDepth: 0 });
+        }
+    }
+    const db = openDb(projectPath);
+    try {
+        const isTestByPath = new Map();
+        for (const row of db.prepare("SELECT path, is_test FROM files").all()) {
+            isTestByPath.set(row.path, row.is_test === 1);
+        }
+        for (const n of nodes) {
+            if (!isTestByPath.get(n.file))
+                continue;
+            const prior = testHits.get(n.file);
+            if (!prior) {
+                testHits.set(n.file, { file: n.file, nodes: 1, minDepth: n.depth });
+            }
+            else {
+                prior.nodes += 1;
+                prior.minDepth = Math.min(prior.minDepth, n.depth);
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+    const tests = [...testHits.values()].sort((a, b) => a.file.localeCompare(b.file));
+    const totalTests = countTestFiles(projectPath);
+    const skippedFiles = Math.max(0, totalTests - tests.length);
+    const percent = totalTests === 0 ? 0 : Math.round((skippedFiles / totalTests) * 100);
+    return {
+        mode: "static",
+        reason: files.length > 0
+            ? `changed ${files.length} file(s)`
+            : query.symbols?.length
+                ? `symbols ${query.symbols.join(", ")}`
+                : "empty selection",
+        tests,
+        skipped: { files: skippedFiles, percent },
+        command: buildTestCommand(projectPath, tests.map((t) => t.file), cfg, tests.length === 0 ? "none" : "subset"),
+        warnings,
+    };
+}
+function listWorktreeChanges(projectPath) {
+    // Prefer merge-base against main/master when available; else HEAD.
+    for (const base of ["main", "master", "HEAD"]) {
+        const files = changedFiles(projectPath, base);
+        if (files.length > 0 || base === "HEAD")
+            return files;
+    }
+    return [];
+}
+function countTestFiles(projectPath) {
+    if (!indexExists(projectPath))
+        return 0;
+    const db = openDb(projectPath);
+    try {
+        const row = db.prepare("SELECT COUNT(*) AS n FROM files WHERE is_test = 1").get();
+        return Number(row.n);
+    }
+    finally {
+        db.close();
+    }
+}
+function listTestFiles(projectPath) {
+    const db = openDb(projectPath);
+    try {
+        return db.prepare("SELECT path FROM files WHERE is_test = 1 ORDER BY path").all().map((r) => r.path);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Build an executable test command from package.json scripts.test when present.
+ *
+ * @param projectPath - Project root.
+ * @param tests - Selected test paths (ignored for mode `all`).
+ * @param _cfg - Reserved for future runner overrides.
+ * @param mode - `all` | `subset` | `none`.
+ */
+export function buildTestCommand(projectPath, tests, _cfg, mode) {
+    const pkgPath = path.join(projectPath, "package.json");
+    let script;
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            script = pkg.scripts?.test;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (mode === "all") {
+        return script ? "npm test" : "node --test";
+    }
+    if (mode === "none" || tests.length === 0) {
+        return script ? "npm test -- --test-name-pattern=^$" : "node --test --test-name-pattern=^$";
+    }
+    const args = tests.map(shellQuote).join(" ");
+    if (script && /\bnode\s+--test\b/.test(script)) {
+        return `node --test ${args}`;
+    }
+    if (script) {
+        // Pass paths after `--` for npm/vitest/jest-style scripts.
+        return `npm test -- ${args}`;
+    }
+    return `node --test ${args}`;
+}
+function shellQuote(p) {
+    if (/^[A-Za-z0-9_./-]+$/.test(p))
+        return p;
+    return `'${p.replace(/'/g, `'\\''`)}'`;
+}
+/** Warn when present extensions are not in the indexed language set. */
+function warnUnindexedLanguages(projectPath) {
+    const indexedExts = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
+    const seen = new Set();
+    const warnings = [];
+    walkQuick(projectPath, (rel) => {
+        const ext = path.extname(rel).toLowerCase();
+        if (!ext || indexedExts.has(ext) || seen.has(ext))
+            return;
+        // Only flag common source extensions that Compass does not parse.
+        if (![".go", ".rs", ".java", ".kt", ".rb", ".php", ".cs"].includes(ext))
+            return;
+        seen.add(ext);
+        warnings.push(`${ext} files are present but not indexed by Compass`);
+    });
+    return warnings;
+}
+function walkQuick(root, visit) {
+    const skip = new Set([".git", "node_modules", "dist", "dist-test", ".speclaw", "vendor"]);
+    const stack = [root];
+    let n = 0;
+    while (stack.length && n < 5000) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith(".") && e.name !== ".speclaw") {
+                if (e.isDirectory() && e.name !== ".github")
+                    continue;
+            }
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (!skip.has(e.name))
+                    stack.push(full);
+            }
+            else if (e.isFile()) {
+                n++;
+                visit(path.relative(root, full));
+            }
+        }
+    }
+}

package/dist/modules/compass/db.js

@@ -10,8 +10,11 @@ CREATE TABLE IF NOT EXISTS files (
   id INTEGER PRIMARY KEY,
   path TEXT UNIQUE NOT NULL,
   hash TEXT NOT NULL,
-  lang TEXT NOT NULL
+  lang TEXT NOT NULL,
+  is_test INTEGER NOT NULL DEFAULT 0,
+  module TEXT NOT NULL DEFAULT ''
 );
+CREATE INDEX IF NOT EXISTS idx_files_is_test ON files(is_test);
 -- nodes: the definitions in the codebase (functions, classes, methods, types).
 CREATE TABLE IF NOT EXISTS nodes (
   id INTEGER PRIMARY KEY,
@@ -101,7 +104,7 @@ CREATE INDEX IF NOT EXISTS idx_anchors_symbol ON spec_anchors(symbol_name);
 CREATE INDEX IF NOT EXISTS idx_anchors_node ON spec_anchors(node_id);
 `;
 /** Schema version stamped into the `meta` table on first creation. */
-export const SCHEMA_VERSION = "6";
+export const SCHEMA_VERSION = "7";
 /** The stamped schema version, or null if the db predates versioning / has no meta table. */
 function readSchemaVersion(db) {
     try {
@@ -127,8 +130,11 @@ function isStale(db) {
         return false;
     if (readSchemaVersion(db) !== SCHEMA_VERSION)
         return true;
-    const cols = db.prepare("PRAGMA table_info(edges)").all().map((c) => c.name);
-    return !cols.includes("src_node_id") || !cols.includes("dst_node_id");
+    const edgeCols = db.prepare("PRAGMA table_info(edges)").all().map((c) => c.name);
+    if (!edgeCols.includes("src_node_id") || !edgeCols.includes("dst_node_id"))
+        return true;
+    const fileCols = db.prepare("PRAGMA table_info(files)").all().map((c) => c.name);
+    return !fileCols.includes("is_test") || !fileCols.includes("module");
 }
 /** Drop every table (children first) so the current schema can be recreated cleanly. */
 function resetSchema(db) {

package/dist/modules/compass/indexer.js

@@ -5,6 +5,7 @@ import { openDb, clearNeedsReindex } from "./db.js";
 import { langForPath } from "./languages.js";
 import { extract } from "./extract.js";
 import { getEmbedder, toBlob } from "./embedder.js";
+import { loadAffectedConfig, isTestPath, inferModule } from "./affected-config.js";
 const SKIP_DIRS = new Set([
     ".git",
     "node_modules",
@@ -29,6 +30,108 @@ const MAX_FILE_BYTES = 1_500_000;
 function hashOf(content) {
     return createHash("sha256").update(content).digest("hex");
 }
+/**
+ * Point import edges at a representative node in the imported file so reverse
+ * reachability can walk file-level dependencies (not just calls).
+ */
+function resolveImportEdges(db, projectPath) {
+    const files = db.prepare("SELECT id, path FROM files").all();
+    const byNorm = new Map();
+    for (const f of files) {
+        byNorm.set(f.path.split("\\").join("/"), f.id);
+    }
+    const firstNode = db.prepare("SELECT id FROM nodes WHERE file_id = ? ORDER BY start_line ASC, id ASC LIMIT 1");
+    const namedNode = db.prepare("SELECT id FROM nodes WHERE file_id = ? AND name = ? ORDER BY id ASC LIMIT 1");
+    const upd = db.prepare("UPDATE edges SET dst_node_id = ? WHERE id = ?");
+    const imports = db
+        .prepare(`SELECT e.id, e.dst_name, e.src_file_id, f.path AS src_path
+       FROM edges e JOIN files f ON f.id = e.src_file_id
+       WHERE e.kind = 'import' AND e.dst_node_id IS NULL`)
+        .all();
+    for (const edge of imports) {
+        const spec = parseImportSpecifier(edge.dst_name);
+        if (!spec)
+            continue;
+        const targetRel = resolveImportPath(projectPath, edge.src_path, spec.from);
+        if (!targetRel)
+            continue;
+        const fileId = byNorm.get(targetRel);
+        if (fileId === undefined)
+            continue;
+        let nodeId;
+        for (const name of spec.names) {
+            const row = namedNode.get(fileId, name);
+            if (row) {
+                nodeId = row.id;
+                break;
+            }
+        }
+        if (nodeId === undefined) {
+            const row = firstNode.get(fileId);
+            nodeId = row?.id;
+        }
+        if (nodeId !== undefined)
+            upd.run(nodeId, edge.id);
+    }
+}
+/** Pull `from` path and optional named imports out of a raw import statement text. */
+function parseImportSpecifier(text) {
+    const fromMatch = text.match(/\bfrom\s+['"]([^'"]+)['"]/) ?? text.match(/require\s*\(\s*['"]([^'"]+)['"]/);
+    if (!fromMatch)
+        return null;
+    const from = fromMatch[1];
+    const names = [];
+    const brace = text.match(/\{([^}]+)\}/);
+    if (brace) {
+        for (const part of brace[1].split(",")) {
+            const id = part
+                .trim()
+                .split(/\s+as\s+/i)[0]
+                .trim();
+            if (id && /^[A-Za-z_$][\w$]*$/.test(id))
+                names.push(id);
+        }
+    }
+    const def = text.match(/\bimport\s+([A-Za-z_$][\w$]*)\s+/);
+    if (def && !text.includes("{"))
+        names.push(def[1]);
+    return { from, names };
+}
+/**
+ * Resolve a relative/absolute-ish import specifier to a project-relative indexed path.
+ */
+function resolveImportPath(projectPath, srcRel, spec) {
+    if (!spec.startsWith(".") && !spec.startsWith("/"))
+        return null; // bare package — skip
+    const srcDir = path.dirname(path.join(projectPath, srcRel));
+    const absBase = path.resolve(srcDir, spec);
+    const candidates = [
+        absBase,
+        absBase.replace(/\.js$/, ".ts"),
+        absBase.replace(/\.js$/, ".tsx"),
+        absBase.replace(/\.jsx$/, ".tsx"),
+        `${absBase}.ts`,
+        `${absBase}.tsx`,
+        `${absBase}.js`,
+        `${absBase}.jsx`,
+        `${absBase}.mjs`,
+        `${absBase}.cjs`,
+        path.join(absBase, "index.ts"),
+        path.join(absBase, "index.js"),
+    ];
+    for (const abs of candidates) {
+        if (!fs.existsSync(abs) || !fs.statSync(abs).isFile())
+            continue;
+        return path.relative(projectPath, abs).split("\\").join("/");
+    }
+    // Fall back without existence check — strip a trailing .js for TS sources.
+    let rel = path.relative(projectPath, absBase).split("\\").join("/");
+    if (rel.endsWith(".js"))
+        rel = rel.slice(0, -3) + ".ts";
+    else if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(rel))
+        rel = `${rel}.ts`;
+    return rel.replace(/^\.\//, "");
+}
 /**
  * Infer a covering artifact's type from its project-relative path.
  * Full glob config lives in lawbook; this is the indexer default so links are
@@ -98,13 +201,14 @@ export async function buildIndex(projectPath, onProgress) {
         removed: 0,
         embedder: embedder.id,
     };
+    const cfg = loadAffectedConfig(projectPath);
     const existing = new Map();
     for (const row of db.prepare("SELECT id, path, hash FROM files").all()) {
         existing.set(row.path, { id: row.id, hash: row.hash });
     }
     const seen = new Set();
-    const insFile = db.prepare("INSERT INTO files(path, hash, lang) VALUES (?, ?, ?)");
-    const updFile = db.prepare("UPDATE files SET hash = ?, lang = ? WHERE id = ?");
+    const insFile = db.prepare("INSERT INTO files(path, hash, lang, is_test, module) VALUES (?, ?, ?, ?, ?)");
+    const updFile = db.prepare("UPDATE files SET hash = ?, lang = ?, is_test = ?, module = ? WHERE id = ?");
     const delNodes = db.prepare("DELETE FROM nodes WHERE file_id = ?");
     const delEdges = db.prepare("DELETE FROM edges WHERE src_file_id = ?");
     const delCoverage = db.prepare("DELETE FROM coverage_links WHERE file_path = ?");
@@ -143,15 +247,17 @@ export async function buildIndex(projectPath, onProgress) {
                 continue;
             }
             let fileId;
+            const isTest = isTestPath(rel, cfg.testGlobs) ? 1 : 0;
+            const mod = inferModule(rel);
             if (prior) {
-                updFile.run(hash, lang.id, prior.id);
+                updFile.run(hash, lang.id, isTest, mod, prior.id);
                 delNodes.run(prior.id);
                 delEdges.run(prior.id);
                 delCoverage.run(rel);
                 fileId = prior.id;
             }
             else {
-                fileId = Number(insFile.run(rel, hash, lang.id).lastInsertRowid);
+                fileId = Number(insFile.run(rel, hash, lang.id, isTest, mod).lastInsertRowid);
             }
             const { symbols, refs, coverage } = await extract(content, lang);
             const nodeIds = [];
@@ -164,8 +270,12 @@ export async function buildIndex(projectPath, onProgress) {
                 insEmbed.run(id, embedder.dim, embedder.id, toBlob(vec));
                 stats.embeddings++;
             }
+            // Prefer a real symbol as import owner when the AST leaves imports file-scoped.
+            const fileOwner = nodeIds[0] ?? null;
             for (const r of refs) {
-                const srcId = r.ownerIndex !== null ? nodeIds[r.ownerIndex] : null;
+                let srcId = r.ownerIndex !== null ? nodeIds[r.ownerIndex] : null;
+                if (srcId === null && r.kind === "import")
+                    srcId = fileOwner;
                 insEdge.run(srcId, fileId, r.name, r.kind, r.line);
                 stats.edges++;
             }
@@ -184,15 +294,17 @@ export async function buildIndex(projectPath, onProgress) {
                 stats.removed++;
             }
         }
-        // resolve call edges to node definitions by name match
+        // Prefer same-file callees so colliding names across files do not share one id.
         db.exec(`
       UPDATE edges SET dst_node_id = (
         SELECT n.id FROM nodes n
         WHERE n.name = edges.dst_name
+        ORDER BY CASE WHEN n.file_id = edges.src_file_id THEN 0 ELSE 1 END, n.id
         LIMIT 1
       )
       WHERE kind = 'call' AND dst_node_id IS NULL
     `);
+        resolveImportEdges(db, projectPath);
         db.prepare("INSERT INTO meta(key, value) VALUES ('indexed_at', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(new Date().toISOString());
         clearNeedsReindex(db);
         db.exec("COMMIT");

package/dist/modules/compass/query.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { openDb, indexExists } from "./db.js";
 import { getEmbedder, fromBlob, cosine } from "./embedder.js";
+import { loadAffectedConfig, filterFilesForTarget, matchGlobalFiles } from "./affected-config.js";
 function requireIndex(projectPath) {
     if (!indexExists(projectPath)) {
         throw new Error("No index found. Build it first with the index_build tool (creates .speclaw/index.db).");
@@ -164,50 +165,274 @@ export async function recall(projectPath, query, limit = 15) {
         db.close();
     }
 }
+const DEFAULT_HARD_LIMIT = 500;
 /**
- * Transitive blast radius: every node that (transitively) calls the target,
- * up to maxDepth hops. Expansion is by call-name, so dynamic dispatch is
- * included — the conservative answer to "what could break if I change this?".
+ * Reverse dependency closure (blast radius) for a symbol or set of files.
+ *
+ * Uses one recursive SQL CTE that prefers `edges.dst_node_id` and falls back to
+ * `dst_name` only when the id is NULL. Default edge kinds are `call` and
+ * `import`. Results are grouped by module unless `format: "flat"`.
  *
  * @param projectPath - Absolute path to the indexed project.
- * @param nodeName - Name of the node whose dependents are wanted.
- * @param maxDepth - Maximum number of call hops to traverse outward.
- * @returns The reached nodes, each tagged with its discovery depth.
- * @throws If no index exists for the project.
+ * @param symbolOrOpts - Symbol name (legacy) or full {@link ImpactQuery}.
+ * @param maxDepth - Used only with the legacy string form.
  */
-export function impact(projectPath, nodeName, maxDepth = 4) {
+export function impact(projectPath, symbolOrOpts, maxDepth = 4) {
+    const opts = typeof symbolOrOpts === "string"
+        ? { symbol: symbolOrOpts, maxDepth }
+        : { maxDepth: 4, ...symbolOrOpts };
     requireIndex(projectPath);
+    const cfg = loadAffectedConfig(projectPath);
+    const depth = Math.max(1, Math.min(12, opts.maxDepth ?? 4));
+    const edgeKinds = opts.edgeKinds?.length ? opts.edgeKinds : ["call", "import"];
+    const hardLimit = opts.hardLimit ?? DEFAULT_HARD_LIMIT;
+    const topModules = opts.topModules ?? 8;
+    const topPerModule = opts.topPerModule ?? 5;
+    const format = opts.format ?? "grouped";
+    const target = opts.target ?? "any";
+    const warnings = [];
     const db = openDb(projectPath);
     try {
-        const visited = new Set();
-        const results = [];
-        let frontier = [nodeName];
-        for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
-            const placeholders = frontier.map(() => "?").join(",");
-            const callers = db
-                .prepare(`SELECT DISTINCT owner.id, owner.name, owner.kind, f.path AS file, MIN(owner.start_line) AS line
-           FROM edges e
-           JOIN nodes owner ON owner.id = e.src_node_id
-           JOIN files f ON f.id = owner.file_id
-           WHERE e.kind = 'call' AND e.dst_name IN (${placeholders})
-           GROUP BY owner.id`)
-                .all(...frontier);
-            const nextNames = new Set();
-            for (const c of callers) {
-                if (visited.has(c.id))
-                    continue;
-                visited.add(c.id);
-                results.push({ name: c.name, kind: c.kind, file: c.file, line: c.line, depth });
-                nextNames.add(c.name);
+        let seedFiles = opts.files ? [...opts.files] : [];
+        if (seedFiles.length > 0) {
+            const filtered = filterFilesForTarget(seedFiles, target, cfg);
+            warnings.push(...filtered.warnings);
+            seedFiles = filtered.included;
+            const glob = matchGlobalFiles(seedFiles, cfg);
+            if (glob.matched.length > 0) {
+                return {
+                    target: { kind: "files", files: seedFiles },
+                    totals: { nodes: 0, files: 0, modules: 0 },
+                    global: {
+                        matched: glob.patterns,
+                        blastRadius: "repo",
+                        reason: `Global file(s) matched (${glob.matched.join(", ")}); treat blast radius as the whole repository`,
+                    },
+                    modules: [],
+                    resolution: { exact: 0, byName: 0 },
+                    limits: { maxDepth: depth, maxDepthReached: false, truncated: false },
+                    warnings,
+                };
+            }
+        }
+        const definitions = resolveImpactSeeds(db, opts, seedFiles, warnings);
+        if (definitions.length === 0 && !opts.symbol && seedFiles.length === 0) {
+            return emptyImpact(opts, seedFiles, depth, warnings);
+        }
+        if (definitions.length === 0) {
+            warnings.push("No seed definitions found in the index for the given target");
+            return emptyImpact(opts, seedFiles, depth, warnings);
+        }
+        const kindPlaceholders = edgeKinds.map(() => "?").join(",");
+        const seedPlaceholders = definitions.map(() => "(?, ?, 0, 0)").join(",");
+        const seedArgs = [];
+        for (const d of definitions) {
+            seedArgs.push(d.nodeId, d.name);
+        }
+        // Sticky by_name: MAX(frontier.by_name, CASE WHEN edge unresolved THEN 1 ELSE 0).
+        // Import edges that resolve to ANY node in the frontier node's file count as hits.
+        const sql = `
+      WITH RECURSIVE
+      frontier(node_id, node_name, depth, by_name) AS (
+        SELECT * FROM (VALUES ${seedPlaceholders})
+        UNION
+        SELECT owner.id,
+               owner.name,
+               f.depth + 1,
+               MAX(f.by_name, CASE
+                 WHEN e.kind = 'import' THEN 0
+                 WHEN e.dst_node_id IS NULL THEN 1
+                 ELSE 0
+               END)
+        FROM frontier f
+        JOIN edges e ON (
+          e.kind IN (${kindPlaceholders})
+          AND (
+            (e.kind = 'call' AND (
+              e.dst_node_id = f.node_id
+              OR (e.dst_node_id IS NULL AND e.dst_name = f.node_name)
+            ))
+            OR (
+              e.kind = 'import'
+              AND e.dst_node_id IS NOT NULL
+              AND EXISTS (
+                SELECT 1 FROM nodes dn
+                WHERE dn.id = e.dst_node_id
+                  AND dn.file_id = (SELECT file_id FROM nodes WHERE id = f.node_id)
+              )
+            )
+          )
+        )
+        JOIN nodes owner ON owner.id = e.src_node_id
+        WHERE f.depth < ?
+      )
+      SELECT r.node_id AS nodeId,
+             r.node_name AS name,
+             n.kind AS kind,
+             fl.path AS file,
+             n.start_line AS line,
+             MIN(r.depth) AS depth,
+             MIN(r.by_name) AS byName,
+             fl.module AS module
+      FROM frontier r
+      JOIN nodes n ON n.id = r.node_id
+      JOIN files fl ON fl.id = n.file_id
+      WHERE r.depth > 0
+      GROUP BY r.node_id
+      ORDER BY depth ASC, file ASC, line ASC
+      LIMIT ?
+    `;
+        const rows = db.prepare(sql).all(...seedArgs, ...edgeKinds, depth, hardLimit + 1);
+        const truncated = rows.length > hardLimit;
+        const sliced = truncated ? rows.slice(0, hardLimit) : rows;
+        const nodes = sliced.map((r) => ({
+            nodeId: r.nodeId,
+            name: r.name,
+            kind: r.kind,
+            file: r.file,
+            line: r.line,
+            depth: r.depth,
+            resolution: r.byName > 0 ? "by-name" : "exact",
+            module: r.module || inferModuleFallback(r.file),
+        }));
+        const exact = nodes.filter((n) => n.resolution === "exact").length;
+        const byName = nodes.length - exact;
+        const maxDepthReached = nodes.some((n) => n.depth >= depth);
+        const targetDesc = opts.symbol || opts.nodeId !== undefined
+            ? {
+                kind: "symbol",
+                symbol: opts.symbol ?? `#${opts.nodeId}`,
+                definitions: definitions.map((d) => ({
+                    nodeId: d.nodeId,
+                    file: d.file,
+                    line: d.line,
+                })),
             }
-            frontier = [...nextNames];
+            : { kind: "files", files: seedFiles };
+        if (format === "flat") {
+            const files = new Set(nodes.map((n) => n.file));
+            const modules = new Set(nodes.map((n) => n.module));
+            return {
+                target: targetDesc,
+                totals: { nodes: nodes.length, files: files.size, modules: modules.size },
+                modules: [],
+                nodes,
+                resolution: { exact, byName },
+                limits: { maxDepth: depth, maxDepthReached, truncated },
+                warnings,
+            };
         }
-        return results;
+        return {
+            target: targetDesc,
+            totals: {
+                nodes: nodes.length,
+                files: new Set(nodes.map((n) => n.file)).size,
+                modules: new Set(nodes.map((n) => n.module)).size,
+            },
+            modules: groupImpactModules(nodes, topModules, topPerModule),
+            resolution: { exact, byName },
+            limits: { maxDepth: depth, maxDepthReached, truncated },
+            warnings,
+        };
     }
     finally {
         db.close();
     }
 }
+function inferModuleFallback(file) {
+    const parts = file.split(/[/\\]/).filter(Boolean);
+    if (parts.length <= 1)
+        return parts[0] ?? ".";
+    return parts.slice(0, 2).join("/");
+}
+function emptyImpact(opts, seedFiles, depth, warnings) {
+    return {
+        target: opts.symbol || opts.nodeId !== undefined
+            ? {
+                kind: "symbol",
+                symbol: opts.symbol ?? `#${opts.nodeId}`,
+                definitions: [],
+            }
+            : { kind: "files", files: seedFiles },
+        totals: { nodes: 0, files: 0, modules: 0 },
+        modules: [],
+        nodes: opts.format === "flat" ? [] : undefined,
+        resolution: { exact: 0, byName: 0 },
+        limits: { maxDepth: depth, maxDepthReached: false, truncated: false },
+        warnings,
+    };
+}
+function resolveImpactSeeds(db, opts, seedFiles, warnings) {
+    if (opts.nodeId !== undefined) {
+        const row = db
+            .prepare(`SELECT n.id AS nodeId, n.name, f.path AS file, n.start_line AS line
+         FROM nodes n JOIN files f ON f.id = n.file_id WHERE n.id = ?`)
+            .get(opts.nodeId);
+        return row ? [row] : [];
+    }
+    if (opts.symbol) {
+        const rows = db
+            .prepare(`SELECT n.id AS nodeId, n.name, f.path AS file, n.start_line AS line
+         FROM nodes n JOIN files f ON f.id = n.file_id
+         WHERE n.name = ?
+         ORDER BY n.kind = 'function' DESC, n.kind = 'class' DESC, n.id ASC
+         LIMIT 50`)
+            .all(opts.symbol);
+        if (rows.length > 1) {
+            warnings.push(`"${opts.symbol}" is defined in ${rows.length} places; impact is the union. Pass nodeId to disambiguate.`);
+        }
+        return rows;
+    }
+    if (seedFiles.length === 0)
+        return [];
+    db.exec("CREATE TEMP TABLE IF NOT EXISTS changed(path TEXT PRIMARY KEY)");
+    db.exec("DELETE FROM changed");
+    const ins = db.prepare("INSERT OR IGNORE INTO changed(path) VALUES (?)");
+    for (const f of seedFiles)
+        ins.run(f.split("\\").join("/"));
+    const indexed = db
+        .prepare(`SELECT n.id AS nodeId, n.name, f.path AS file, n.start_line AS line
+       FROM nodes n
+       JOIN files f ON f.id = n.file_id
+       JOIN changed c ON c.path = f.path`)
+        .all();
+    const indexedPaths = new Set(indexed.map((r) => r.file));
+    for (const f of seedFiles) {
+        const norm = f.split("\\").join("/");
+        if (!indexedPaths.has(norm)) {
+            warnings.push(`${norm} is not indexed; run compass_index`);
+        }
+    }
+    return indexed;
+}
+function groupImpactModules(nodes, topModules, topPerModule) {
+    const byMod = new Map();
+    for (const n of nodes) {
+        const list = byMod.get(n.module) ?? [];
+        list.push(n);
+        byMod.set(n.module, list);
+    }
+    const modules = [];
+    for (const [module, list] of byMod) {
+        list.sort((a, b) => {
+            if (a.depth !== b.depth)
+                return a.depth - b.depth;
+            if (a.resolution !== b.resolution)
+                return a.resolution === "exact" ? -1 : 1;
+            return a.file.localeCompare(b.file) || a.line - b.line;
+        });
+        modules.push({
+            module,
+            nodes: list.length,
+            files: new Set(list.map((n) => n.file)).size,
+            minDepth: list[0]?.depth ?? 0,
+            byName: list.filter((n) => n.resolution === "by-name").length,
+            top: list.slice(0, topPerModule),
+        });
+    }
+    modules.sort((a, b) => b.nodes - a.nodes || a.module.localeCompare(b.module));
+    return modules.slice(0, topModules);
+}
 /**
  * Trace a call path from one node to another: BFS forward over call edges (by
  * name) from `from` until `to` is reached, returning the chain of names. null

package/dist/modules/compass/register.js

@@ -3,6 +3,7 @@ import { defineTool, text } from "../../shared/mcp.js";
 import { shouldExpose } from "../../shared/exposure.js";
 import { buildIndex } from "./indexer.js";
 import { explore, search, recall, impact, trace } from "./query.js";
+import { affectedTests } from "./affected.js";
 import { startWatch, stopWatch, watchStatus } from "./watcher.js";
 import { visualize } from "./visualize.js";
 // ─── Compass: speclaw's own code-intelligence engine (no external deps) ───
@@ -23,7 +24,37 @@ export function registerCompass(server, opts = {}) {
     add("compass_explore", "Read a symbol's source plus callers and callees. Prefer this before grep or Read.", { projectPath: z.string(), node: z.string() }, async ({ projectPath, node }) => text(explore(projectPath, node)));
     add("compass_search", "Find symbols by name or keyword (substring). Cheaper structural search than grep.", { projectPath: z.string(), query: z.string(), limit: z.number().optional() }, async ({ projectPath, query, limit }) => text(search(projectPath, query, limit ?? 25)));
     add("compass_recall", "Find symbols by meaning via local embeddings. Use when names are unknown.", { projectPath: z.string(), query: z.string(), limit: z.number().optional() }, async ({ projectPath, query, limit }) => text(await recall(projectPath, query, limit ?? 15)));
-    add("compass_impact", "List transitive callers of a symbol (blast radius) before editing.", { projectPath: z.string(), node: z.string(), maxDepth: z.number().optional() }, async ({ projectPath, node, maxDepth }) => text(impact(projectPath, node, maxDepth ?? 4)));
+    add("compass_impact", "Blast radius for a symbol or files, grouped by module (not a flat dump).", {
+        projectPath: z.string(),
+        /** @deprecated Prefer `symbol`. Kept for existing callers. */
+        node: z.string().optional(),
+        symbol: z.string().optional(),
+        files: z.array(z.string()).optional(),
+        nodeId: z.number().int().optional(),
+        maxDepth: z.number().int().min(1).max(12).optional(),
+        edgeKinds: z.array(z.enum(["call", "import"])).optional(),
+        target: z.enum(["build", "test", "lint", "any"]).optional(),
+        format: z.enum(["grouped", "flat"]).optional(),
+        topModules: z.number().int().min(1).max(50).optional(),
+        topPerModule: z.number().int().min(1).max(50).optional(),
+    }, async (args) => text(impact(args.projectPath, {
+        symbol: args.symbol ?? args.node,
+        files: args.files,
+        nodeId: args.nodeId,
+        maxDepth: args.maxDepth ?? 4,
+        edgeKinds: args.edgeKinds,
+        target: args.target,
+        format: args.format ?? "grouped",
+        topModules: args.topModules,
+        topPerModule: args.topPerModule,
+    })));
+    add("compass_affected_tests", "Select test files affected by a change; returns a ready-to-run command.", {
+        projectPath: z.string(),
+        files: z.array(z.string()).optional(),
+        symbols: z.array(z.string()).optional(),
+        fromDiff: z.string().optional(),
+        maxDepth: z.number().int().min(1).max(12).optional(),
+    }, async ({ projectPath, files, symbols, fromDiff, maxDepth }) => text(affectedTests(projectPath, { files, symbols, fromDiff, maxDepth })));
     add("compass_trace", "Find a call path between two symbols within a depth limit.", {
         projectPath: z.string(),
         from: z.string(),

package/dist/shared/exposure.js

@@ -11,6 +11,7 @@ export const MINIMAL_OMIT = new Set([
     "compass_index",
     "compass_watch",
     "compass_impact",
+    "compass_affected_tests",
     "compass_trace",
     "compass_visualize",
     "lawbook_init",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esneiderbravo/speclaw",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "publishConfig": {
     "access": "public"
   },