@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/change-narrative.test.js

@@ -0,0 +1,190 @@
+/**
+ * BA-3.5: Change Impact Narrative + Agent-as-LLM Bridge tests.
+ *
+ * Verifies:
+ *   - Narrative includes all behavior signals
+ *   - Markdown well-formed
+ *   - Risk level computed correctly
+ *   - Counterfactual framing always present
+ *   - Agent-as-LLM templates, timeout, budget, follow-through
+ */
+import { describe, expect, it } from "vitest";
+import { AgentLlmBridge } from "../behaviors/agent-llm-bridge.js";
+import { ChangeNarrativeBehavior } from "../behaviors/change-narrative.js";
+function makeCtx() {
+    return {
+        toolName: "__session_end__",
+        args: {},
+        sessionId: "test-session",
+    };
+}
+// ── Change Narrative Tests ─────────────────────────────────────
+describe("Change Impact Narrative (BA-3.2)", () => {
+    describe("Behavior Identity", () => {
+        it("has correct id and hooks", () => {
+            const narrative = new ChangeNarrativeBehavior();
+            expect(narrative.id).toBe("change_narrative");
+            expect(narrative.hooks).toContain("session_end");
+            expect(narrative.defaultLevel).toBe("suggestion");
+        });
+    });
+    describe("Empty Session", () => {
+        it("returns null when no behaviors have data", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            expect(output).toBeNull();
+        });
+    });
+    describe("Risk Level Computation", () => {
+        it("returns low risk for clean session", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            expect(output).toBeNull();
+        });
+    });
+    describe("Counterfactual Framing", () => {
+        it("produces counterfactual for clean sessions (no issues)", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            if (output) {
+                const ctx = output._context?.change_narrative;
+                expect(ctx.counterfactual).toContain("Clean session");
+            }
+        });
+    });
+    describe("Markdown Output", () => {
+        it("generates well-formed markdown when behaviors have data", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            if (output) {
+                const ctx = output._context?.change_narrative;
+                expect(ctx.markdown).toContain("## Change Impact");
+            }
+        });
+    });
+});
+// ── Agent-as-LLM Bridge Tests ──────────────────────────────────
+describe("Agent-as-LLM Bridge (BA-3.3)", () => {
+    describe("Template System", () => {
+        it("lists all available templates", () => {
+            const templates = AgentLlmBridge.getTemplates();
+            expect(templates).toContain("session_resume");
+            expect(templates).toContain("doc_generation");
+            expect(templates).toContain("loop_diagnosis");
+            expect(templates).toContain("convention_fix");
+            expect(templates).toContain("cascade_fix");
+            expect(templates).toContain("architecture_alternative");
+            expect(templates.length).toBeGreaterThanOrEqual(7);
+        });
+        it("returns template definition with prefix and maxTokens", () => {
+            const def = AgentLlmBridge.getTemplateDefinition("loop_diagnosis");
+            expect(def.prefix).toContain("Analyze why");
+            expect(def.maxTokens).toBe(500);
+            expect(def.priority).toBe("high");
+        });
+        it("creates prompt with template prefix and context", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "Function processPayment(amount: number, currency: string): Promise<Receipt>");
+            expect(prompt.template).toBe("doc_generation");
+            expect(prompt.content).toContain("Generate documentation");
+            expect(prompt.content).toContain("processPayment");
+            expect(prompt.priority).toBe("low");
+        });
+    });
+    describe("Timeout Handling", () => {
+        it("defaults to 5000ms timeout", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("session_resume", "test context");
+            expect(prompt.timeoutMs).toBe(5000);
+        });
+        it("accepts custom timeout", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("session_resume", "test context", {
+                timeoutMs: 3000,
+            });
+            expect(prompt.timeoutMs).toBe(3000);
+        });
+    });
+    describe("Fallback Handling", () => {
+        it("stores fallback content", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test", {
+                fallback: "AST-based docs only",
+            });
+            expect(prompt.fallbackContent).toBe("AST-based docs only");
+        });
+        it("fallback is null by default", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test");
+            expect(prompt.fallbackContent).toBeNull();
+        });
+    });
+    describe("Injection and Budget", () => {
+        it("injects prompt and tracks it", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("loop_diagnosis", "4 failed attempts on processPayment");
+            const injected = bridge.inject(prompt);
+            expect(injected).toContain("Analyze why");
+            expect(bridge.getStats().totalInjected).toBe(1);
+        });
+        it("respects per-call prompt budget", () => {
+            const bridge = new AgentLlmBridge();
+            for (let i = 0; i < 5; i++) {
+                const prompt = bridge.createPrompt("loop_diagnosis", "x".repeat(2000));
+                bridge.inject(prompt);
+            }
+            const overBudget = bridge.createPrompt("doc_generation", "x".repeat(2000));
+            const result = bridge.inject(overBudget);
+            expect(result).toBe("");
+        });
+        it("resets budget between calls", () => {
+            const bridge = new AgentLlmBridge();
+            const longContext = "x".repeat(3800);
+            const prompt1 = bridge.createPrompt("loop_diagnosis", longContext);
+            bridge.inject(prompt1);
+            bridge.resetCallBudget();
+            const prompt2 = bridge.createPrompt("doc_generation", "short context");
+            const result = bridge.inject(prompt2);
+            expect(result.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Follow-Through Tracking", () => {
+        it("starts with 0% follow-through rate", () => {
+            const bridge = new AgentLlmBridge();
+            expect(bridge.getFollowThroughRate()).toBe(0);
+        });
+        it("tracks follow-through when recorded", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test");
+            bridge.inject(prompt);
+            const injectionId = bridge.getLastInjectionId();
+            expect(injectionId).toBeTruthy();
+            bridge.recordFollowThrough(injectionId);
+            expect(bridge.getStats().followedThrough).toBe(1);
+        });
+        it("computes follow-through rate correctly", () => {
+            const bridge = new AgentLlmBridge();
+            const p1 = bridge.createPrompt("doc_generation", "test1");
+            bridge.inject(p1);
+            const id1 = bridge.getLastInjectionId();
+            bridge.recordFollowThrough(id1);
+            bridge.resetCallBudget();
+            const p2 = bridge.createPrompt("convention_fix", "test2");
+            bridge.inject(p2);
+            expect(bridge.getFollowThroughRate()).toBe(0.5);
+        });
+    });
+    describe("Stats", () => {
+        it("tracks injections by template type", () => {
+            const bridge = new AgentLlmBridge();
+            bridge.inject(bridge.createPrompt("doc_generation", "a"));
+            bridge.resetCallBudget();
+            bridge.inject(bridge.createPrompt("doc_generation", "b"));
+            bridge.resetCallBudget();
+            bridge.inject(bridge.createPrompt("loop_diagnosis", "c"));
+            const stats = bridge.getStats();
+            expect(stats.byTemplate.doc_generation).toBe(2);
+            expect(stats.byTemplate.loop_diagnosis).toBe(1);
+        });
+    });
+});

package/dist/__tests__/check-commit.test.js

@@ -0,0 +1,258 @@
+/**
+ * Tests for pre-commit convention check (Sprint 4, Task 4.2).
+ *
+ * Tests the blocking mode detection algorithm, config gating logic,
+ * staged file filtering, graph loading graceful degradation,
+ * and violation evaluation pipeline.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+describe("Check-Commit Hook", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `unerr-test-check-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("pre-commit hook script is valid shell with shebang and non-blocking exit", () => {
+        const hookScript = `#!/bin/sh
+# unerr pre-commit convention check
+if command -v unerr &> /dev/null; then
+  unerr check-commit 2>/dev/null
+fi
+# Non-blocking — always allow commit
+exit 0
+`;
+        expect(hookScript.startsWith("#!/bin/sh")).toBe(true);
+        expect(hookScript.trimEnd().endsWith("exit 0")).toBe(true);
+        expect(hookScript).toContain("unerr check-commit");
+        // Stderr redirect ensures no noise in git output
+        expect(hookScript).toContain("2>/dev/null");
+        // command -v check ensures graceful degradation when unerr not installed
+        expect(hookScript).toContain("command -v unerr");
+    });
+    describe("blocking mode detection algorithm", () => {
+        it("defaults to non-blocking when no settings exist", () => {
+            const settingsPath = join(tempDir, ".unerr", "settings.json");
+            expect(existsSync(settingsPath)).toBe(false);
+            const optsBlocking = undefined;
+            let blockingMode = optsBlocking ?? false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                blockingMode = true;
+            }
+            expect(blockingMode).toBe(false);
+        });
+        it("reads blocking=true from settings.json when CLI flag not set", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ hooks: { precommit: { blocking: true } } }));
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                blockingMode = settings.hooks?.precommit?.blocking ?? false;
+            }
+            expect(blockingMode).toBe(true);
+        });
+        it("CLI --blocking flag takes precedence over settings.json", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ hooks: { precommit: { blocking: false } } }));
+            const optsBlocking = true;
+            let blockingMode = optsBlocking ?? false;
+            const settingsPath = join(settingsDir, "settings.json");
+            if (!blockingMode && existsSync(settingsPath)) {
+                blockingMode = false;
+            }
+            expect(blockingMode).toBe(true);
+        });
+        it("handles malformed settings.json without crashing", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), "NOT VALID JSON!!!");
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                try {
+                    const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                    blockingMode = settings.hooks?.precommit?.blocking ?? false;
+                }
+                catch {
+                    // Should catch and keep blockingMode false
+                }
+            }
+            expect(blockingMode).toBe(false);
+        });
+        it("handles settings.json with missing hooks section", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ theme: "dark" }));
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                blockingMode = settings.hooks?.precommit?.blocking ?? false;
+            }
+            expect(blockingMode).toBe(false);
+        });
+    });
+    describe("config gating", () => {
+        it("skips when no .unerr/config.json exists", () => {
+            const configPath = join(tempDir, ".unerr", "config.json");
+            expect(existsSync(configPath)).toBe(false);
+        });
+        it("proceeds when .unerr/config.json exists with repoId", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), JSON.stringify({
+                repoId: "test-repo",
+            }));
+            const configPath = join(unerrDir, "config.json");
+            expect(existsSync(configPath)).toBe(true);
+            const config = JSON.parse(require("node:fs").readFileSync(configPath, "utf-8"));
+            expect(config.repoId).toBe("test-repo");
+        });
+        it("skips when config.json has no repoId", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), JSON.stringify({ orgId: "org-1" }));
+            const config = JSON.parse(require("node:fs").readFileSync(join(unerrDir, "config.json"), "utf-8"));
+            expect(config.repoId).toBeUndefined();
+        });
+        it("skips when config.json is malformed", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), "{invalid json}}}");
+            let repoId;
+            try {
+                const config = JSON.parse(require("node:fs").readFileSync(join(unerrDir, "config.json"), "utf-8"));
+                repoId = config.repoId;
+            }
+            catch {
+                repoId = undefined;
+            }
+            expect(repoId).toBeUndefined();
+        });
+    });
+    describe("staged file filtering", () => {
+        const SUPPORTED_EXTENSIONS = new Set([
+            ".ts",
+            ".tsx",
+            ".js",
+            ".jsx",
+            ".py",
+            ".go",
+        ]);
+        it("filters to supported file extensions", () => {
+            const stagedFiles = [
+                "src/index.ts",
+                "README.md",
+                "src/app.tsx",
+                "package.json",
+                "main.go",
+                "script.py",
+                "image.png",
+                "style.css",
+            ];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toEqual([
+                "src/index.ts",
+                "src/app.tsx",
+                "main.go",
+                "script.py",
+            ]);
+        });
+        it("returns empty array when no supported files staged", () => {
+            const stagedFiles = ["README.md", "package.json", "image.png"];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toHaveLength(0);
+        });
+        it("handles files with multiple dots correctly", () => {
+            const stagedFiles = ["src/app.test.ts", "config.prod.json", "lib.d.ts"];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toEqual(["src/app.test.ts", "lib.d.ts"]);
+        });
+    });
+    describe("violation display logic", () => {
+        it("counts errors and warnings separately", () => {
+            const violations = [
+                { severity: "error", message: "bad naming" },
+                { severity: "warning", message: "could improve" },
+                { severity: "error", message: "missing type" },
+                { severity: "info", message: "suggestion" },
+            ];
+            const errorCount = violations.filter((v) => v.severity === "error").length;
+            const warningCount = violations.filter((v) => v.severity === "warning").length;
+            expect(errorCount).toBe(2);
+            expect(warningCount).toBe(1);
+        });
+        it("formats violation summary correctly", () => {
+            const totalViolations = 5;
+            const errorCount = 2;
+            const warningCount = 3;
+            const errorSuffix = errorCount > 0
+                ? ` (${errorCount} error${errorCount !== 1 ? "s" : ""})`
+                : "";
+            const warnSuffix = warningCount > 0
+                ? ` (${warningCount} warning${warningCount !== 1 ? "s" : ""})`
+                : "";
+            const summary = `${totalViolations} violation${totalViolations !== 1 ? "s" : ""} found${errorSuffix}${warnSuffix}`;
+            expect(summary).toBe("5 violations found (2 errors) (3 warnings)");
+        });
+        it("handles singular forms correctly", () => {
+            const count = 1;
+            const errCount = 1;
+            const summary = `${count} violation${count !== 1 ? "s" : ""} found (${errCount} error${errCount !== 1 ? "s" : ""})`;
+            expect(summary).toBe("1 violation found (1 error)");
+        });
+    });
+    describe("graph loading graceful degradation", () => {
+        it("returns null when manifest does not exist", () => {
+            const manifestPath = join(tempDir, "manifests", "test-repo.json");
+            expect(existsSync(manifestPath)).toBe(false);
+        });
+        it("returns null when snapshot file does not exist", () => {
+            const manifestsDir = join(tempDir, "manifests");
+            mkdirSync(manifestsDir, { recursive: true });
+            writeFileSync(join(manifestsDir, "test-repo.json"), JSON.stringify({ entityCount: 100, edgeCount: 200 }));
+            const snapshotsDir = join(tempDir, "snapshots");
+            const gzPath = join(snapshotsDir, "test-repo.msgpack.gz");
+            const rawPath = join(snapshotsDir, "test-repo.msgpack");
+            expect(existsSync(gzPath)).toBe(false);
+            expect(existsSync(rawPath)).toBe(false);
+        });
+    });
+    describe("exit code logic", () => {
+        it("exit 0 in non-blocking mode with violations", () => {
+            const blockingMode = false;
+            const hasViolations = true;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(0);
+        });
+        it("exit 1 in blocking mode with violations", () => {
+            const blockingMode = true;
+            const hasViolations = true;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(1);
+        });
+        it("exit 0 in blocking mode without violations", () => {
+            const blockingMode = true;
+            const hasViolations = false;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(0);
+        });
+    });
+});

package/dist/__tests__/checksum.test.js

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+describe("checksum verification", () => {
+    function computeChecksum(buf) {
+        return createHash("sha256").update(buf).digest("hex");
+    }
+    it("produces 64-char hex string", () => {
+        const buf = Buffer.from("hello world");
+        const checksum = computeChecksum(buf);
+        expect(checksum).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it("is deterministic", () => {
+        const buf = Buffer.from("test data");
+        expect(computeChecksum(buf)).toBe(computeChecksum(buf));
+    });
+    it("detects tampered buffer", () => {
+        const original = Buffer.from("original data");
+        const originalChecksum = computeChecksum(original);
+        const tampered = Buffer.from("tampered data");
+        const tamperedChecksum = computeChecksum(tampered);
+        expect(originalChecksum).not.toBe(tamperedChecksum);
+    });
+    it("matches known SHA-256 value", () => {
+        // SHA-256 of empty string is well-known
+        const empty = Buffer.from("");
+        const checksum = computeChecksum(empty);
+        expect(checksum).toBe("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+    });
+    it("handles large buffers", () => {
+        const largeBuf = Buffer.alloc(1024 * 1024, 0x42); // 1MB of 'B'
+        const checksum = computeChecksum(largeBuf);
+        expect(checksum).toMatch(/^[0-9a-f]{64}$/);
+    });
+});

package/dist/__tests__/commit-watcher.test.js

@@ -0,0 +1,154 @@
+/**
+ * P10-TEST-06 (partial): Commit watcher tests — HEAD polling, commit association.
+ */
+import { execSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CommitWatcher } from "../tracking/commit-watcher.js";
+import { IntentCorrelator } from "../tracking/intent-correlator.js";
+import { ShadowLedger } from "../tracking/shadow-ledger.js";
+let tempDir;
+let unerrDir;
+let repoDir;
+function initGitRepo() {
+    repoDir = join(tempDir, "repo");
+    mkdirSync(repoDir, { recursive: true });
+    execSync("git init", { cwd: repoDir, stdio: "pipe" });
+    execSync("git config user.email 'test@test.com'", {
+        cwd: repoDir,
+        stdio: "pipe",
+    });
+    execSync("git config user.name 'Test'", { cwd: repoDir, stdio: "pipe" });
+    writeFileSync(join(repoDir, "README.md"), "# Test");
+    execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+    execSync("git commit -m 'initial'", { cwd: repoDir, stdio: "pipe" });
+}
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-commit-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+    initGitRepo();
+    unerrDir = join(repoDir, ".unerr");
+    mkdirSync(unerrDir, { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+describe("CommitWatcher", () => {
+    it("captures initial HEAD SHA on start", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        const headSha = execSync("git rev-parse HEAD", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        expect(watcher.getLastHeadSha()).toBe(headSha);
+        watcher.stop();
+    });
+    it("detects new commit and extracts changed files", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const commits = [];
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            onCommit: (sha, files, associated) => {
+                commits.push({ sha, files, associated });
+            },
+        });
+        await watcher.start();
+        mkdirSync(join(repoDir, "src"), { recursive: true });
+        writeFileSync(join(repoDir, "src", "auth.ts"), "export function login() {}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add auth'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(commits).toHaveLength(1);
+        expect(commits[0]?.files).toContain("src/auth.ts");
+        const newHead = execSync("git rev-parse HEAD", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        expect(commits[0]?.sha).toBe(newHead);
+        watcher.stop();
+    });
+    it("associates pending correlations on commit", async () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", { key: "abc" }, { found: true }, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            prompt: "Fix auth",
+            files: [{ path: "src/auth.ts", content: "..." }],
+        });
+        expect(correlator.getPendingCount()).toBe(1);
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        mkdirSync(join(repoDir, "src"), { recursive: true });
+        writeFileSync(join(repoDir, "src", "auth.ts"), "export function login() {}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add auth'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(correlator.getPendingCount()).toBe(0);
+        expect(correlator.getCommittedUnflushed()).toHaveLength(1);
+        expect(correlator.getCommittedUnflushed()[0]?.commitSha).toBeTruthy();
+        watcher.stop();
+    });
+    it("does not fire callback when HEAD unchanged", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        let callCount = 0;
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            onCommit: () => {
+                callCount++;
+            },
+        });
+        await watcher.start();
+        await watcher.poll();
+        await watcher.poll();
+        expect(callCount).toBe(0);
+        watcher.stop();
+    });
+    it("handles non-git directory gracefully", async () => {
+        const nonGitDir = join(tempDir, "not-a-repo");
+        mkdirSync(nonGitDir, { recursive: true });
+        const nonGitUnerrDir = join(nonGitDir, ".unerr");
+        mkdirSync(nonGitUnerrDir, { recursive: true });
+        const correlator = new IntentCorrelator(nonGitUnerrDir);
+        const watcher = new CommitWatcher(correlator, { cwd: nonGitDir });
+        await watcher.start();
+        await watcher.poll();
+        expect(watcher.getLastHeadSha()).toBeNull();
+        watcher.stop();
+    });
+    it("skips non-overlapping files during association", async () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "src/billing.ts", content: "..." }],
+        });
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        writeFileSync(join(repoDir, "config.json"), "{}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add config'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(correlator.getPendingCount()).toBe(1);
+        expect(correlator.getCommittedUnflushed()).toHaveLength(0);
+        watcher.stop();
+    });
+    it("stop prevents further polling", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            pollIntervalMs: 10,
+        });
+        await watcher.start();
+        watcher.stop();
+        expect(watcher.getLastHeadSha()).toBeTruthy();
+    });
+});