Doc-sync applies a doc change twice when the turn updated and committed the doc through Bash #2471

diff --git a/hooks/lib/micro-integrity.ts b/hooks/lib/micro-integrity.ts
index d126cd6..b8de88f 100644
--- a/hooks/lib/micro-integrity.ts
+++ b/hooks/lib/micro-integrity.ts
@@ -413,7 +413,10 @@ export async function microIntegrity(session: string, calls: ToolCall[], deps: R
 
     // Pass 2: one model call over the docs that name what changed.
     const renamedOnly = new Set(touched.changes.filter((c) => c.kind === "R").flatMap((c) => spellings({ repo: c.repo, rel: c.from! }, deps.roots)));
-    const eligible = [...hits].filter(([abs, found]) => !touched.editedThisTurn.has(abs) && [...found].some((n) => !renamedOnly.has(n)));
+    // A doc the turn committed is the turn's own update, even when Bash wrote it rather than an edit tool. Sent beside
+    // a diff from before the turn, the model would apply the same change a second time.
+    const changedThisTurn = new Set(touched.changes.map((c) => c.abs));
+    const eligible = [...hits].filter(([abs, found]) => !touched.editedThisTurn.has(abs) && !changedThisTurn.has(abs) && [...found].some((n) => !renamedOnly.has(n)));
     for (const [abs] of eligible.filter(([abs]) => dirty.has(abs))) skipped.push({ doc: docInfo(abs)?.label ?? abs, reason: "has uncommitted changes" });
     const ranked = eligible.filter(([abs]) => !dirty.has(abs))
       // Docs that name a changed file outrank docs that only list its folder.
diff --git a/hooks/lib/micro-integrity.test.ts b/hooks/lib/micro-integrity.test.ts
new file mode 100644
index 0000000..ac8208f
--- /dev/null
+++ b/hooks/lib/micro-integrity.test.ts
@@ -0,0 +1,75 @@
+/**
+ * micro-integrity.test.ts — a doc the turn already updated and committed is never sent to the doc-sync model,
+ * however it was written. Each case builds two scratch git repos (no network, no model: the infer stub records
+ * the prompt).
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { microIntegrity } from "./micro-integrity";
+
+const sh = (cwd: string, ...a: string[]): string => {
+  const r = Bun.spawnSync(a, { cwd, stdout: "pipe", stderr: "pipe" });
+  if (r.exitCode !== 0) throw new Error(`${a.join(" ")}: ${r.stderr}`);
+  return r.stdout.toString().trim();
+};
+const series = (n: number) => `export const S = [\n${Array.from({ length: n }, (_, i) => `  "s${i}",`).join("\n")}\n];\n`;
+const docText = (n: number) => `# X\n\n\`Tools/LiveCatalog.ts\` holds the ${n} series the report covers.\n`;
+
+/** A turn that adds one catalog series (Edit tool); `docBy` says how the doc was updated, or "none". */
+async function runTurn(docBy: "bash-committed" | "edit-tool" | "none"): Promise<{ prompt: string; considered: string[] }> {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "mi-test-")));
+  try {
+    const claude = join(root, "claude"), user = join(root, "user");
+    for (const d of [claude, user]) {
+      mkdirSync(d, { recursive: true });
+      sh(d, "git", "init", "-q"); sh(d, "git", "config", "user.email", "t@t"); sh(d, "git", "config", "user.name", "t");
+    }
+    writeFileSync(join(user, ".keep"), ""); sh(user, "git", "add", "."); sh(user, "git", "commit", "-qm", "init");
+    const cat = join(claude, "skills/X/Tools/LiveCatalog.ts"), doc = join(claude, "skills/X/SKILL.md");
+    mkdirSync(join(claude, "skills/X/Tools"), { recursive: true });
+    writeFileSync(cat, series(16)); writeFileSync(doc, docText(16));
+    sh(claude, "git", "add", "."); sh(claude, "git", "commit", "-qm", "base");
+
+    const t0 = Date.now();
+    writeFileSync(cat, series(17));
+    if (docBy !== "none") writeFileSync(doc, docText(17));
+    sh(claude, "git", "add", "."); sh(claude, "git", "commit", "-qm", "add a series");
+    const hash = sh(claude, "git", "rev-parse", "--short", "HEAD");
+    const calls = [
+      { id: "1", name: "Edit", input: { file_path: cat }, answered: true, ok: true, resultText: "ok", ts: t0 },
+      ...(docBy === "edit-tool" ? [{ id: "2", name: "Edit", input: { file_path: doc }, answered: true, ok: true, resultText: "ok", ts: t0 + 1 }] : []),
+      ...(docBy === "bash-committed" ? [{ id: "2", name: "Bash", input: { command: "sed -i 's/16/17/' skills/X/SKILL.md" }, answered: true, ok: true, resultText: "", ts: t0 + 1 }] : []),
+      { id: "3", name: "Bash", input: { command: "bun CommitOwn.ts" }, answered: true, ok: true, resultText: `{"ok":true,"commit":"${hash}"}`, ts: t0 + 2 },
+    ];
+    let prompt = "";
+    const res = await microIntegrity("t", calls as any, {
+      roots: { claude, user },
+      stateDir: join(root, "state"),
+      infer: async (_s, u) => { prompt = u; return { success: true, parsed: { edits: [] } }; },
+      commit: () => ({ ok: true }),
+    });
+    return { prompt, considered: res?.considered ?? [] };
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+describe("doc-sync skips docs the turn committed", () => {
+  test("a doc the turn updated through Bash and committed is not sent to the model", async () => {
+    const r = await runTurn("bash-committed");
+    expect(r.considered).not.toContain("skills/X/SKILL.md");
+    expect(r.prompt).not.toContain("### Doc: skills/X/SKILL.md");
+  });
+
+  test("a doc the turn updated with an edit tool is still not sent (upstream behaviour kept)", async () => {
+    expect((await runTurn("edit-tool")).considered).not.toContain("skills/X/SKILL.md");
+  });
+
+  test("a doc the turn left alone is still sent, so drift the turn caused still gets fixed", async () => {
+    const r = await runTurn("none");
+    expect(r.considered).toContain("skills/X/SKILL.md");
+    expect(r.prompt).toContain("holds the 16 series");
+  });
+});