@davesheffer/hunch 0.17.2 → 0.18.0

package/README.md

@@ -86,6 +86,12 @@ afterward to pick up the `hunch_*` tools. Each teammate runs `hunch init` once;
 > Synthesis is billed to **your coding-assistant subscription** (Claude/Codex/Cursor CLI),
 > **never** a pay-per-token API key — and falls back to a deterministic heuristic if no CLI
 > is present. Details: [Synthesis & billing](https://hunch-pi.vercel.app/docs#synthesis).
+>
+> **Deep Synthesis** (`backfill --deep` / `sync --deep`): if you're signed into more than one
+> CLI, fan the commit out to *all* of them and reconcile the drafts into one — confidence is
+> **agreement-weighted** (capped below the enforcement threshold, so it stays advisory).
+> Subscription-only, never on the guard path, and it degrades to the single-provider path with
+> one CLI.
 > On Windows, prefer `hunch init` over a global `claude mcp add`; if tools don't appear,
 > `hunch doctor` heals it ([why](https://hunch-pi.vercel.app/docs#windows)).
 
@@ -168,7 +174,9 @@ env var, no shell-profile edit** (and `HUNCH_PRIVATE_DIR` still overrides per-sh
 default-off** (no config → fully inert), and **leak-safe by construction**: committed files and
 the CI PR comment render *public-only*, so a private record can't reach a public surface. Record
 sensitive items with `private: true` (`hunch_record_decision` / `hunch_record_correction`);
-post-commit synthesis can route there too. → [docs](https://hunch-pi.vercel.app/docs#private)
+post-commit synthesis can route there too, and `hunch private --auto-commit` (opt-in)
+auto-commits + pushes each capture to the private repo — recursion-safe, staging only `.hunch/`.
+→ [docs](https://hunch-pi.vercel.app/docs#private)
 
 ## Continuous learning (CI)
 

package/dist/cli/index.js

@@ -67,6 +67,7 @@ program
     .option("--no-agent-hooks", "skip installing the Claude Code agent hooks (.claude/settings.json)")
     .option("--firmness <level>", "agent-hook firmness: off | advisory | firm | strict")
     .option("--private-sync", "post-commit synthesis writes captured decisions into the private overlay (HUNCH_PRIVATE_DIR), never the public repo")
+    .option("--auto-commit", "opt-in: the post-commit hook also git add+commit+pushes the captured decision (the repo it landed in)")
     .action((opts) => {
     // Validate --firmness up front, before any side effects (indexing, git hooks,
     // .mcp.json) or opening the store — a bad value must not leave a half-init.
@@ -95,8 +96,8 @@ program
             console.log(`  ⚠ ${res.skipped} file(s) could not be parsed (skipped)`);
     }
     if (isGitRepo(root)) {
-        const h = installPostCommitHook(root, inv.shell, { private: opts.privateSync });
-        console.log(`  ✓ post-commit hook ${h.action} (learning loop)${opts.privateSync ? " — syncs to the private overlay" : ""}`);
+        const h = installPostCommitHook(root, inv.shell, { private: opts.privateSync, commit: opts.autoCommit });
+        console.log(`  ✓ post-commit hook ${h.action} (learning loop)${opts.privateSync ? " — syncs to the private overlay" : ""}${opts.autoCommit ? " — auto-commit+push on" : ""}`);
         const m = installMergeDriver(root, inv.shell);
         console.log(`  ✓ team merge driver ${m.action}`);
         // Auto-install the pre-commit guard by default (advisory: flags invariants
@@ -185,6 +186,7 @@ program
     .option("--since <spec>", "how far back, e.g. 90d", "90d")
     .option("--max <n>", "max commits to process", "40")
     .option("--concurrency <n>", "commits to synthesize in parallel (the LLM call is the bottleneck)", "4")
+    .option("--deep", "Deep Synthesis: ensemble every available subscription CLI per commit and reconcile their drafts (slower, higher-quality; advisory)")
     .action(async (opts) => {
     const { store, root } = storeFor();
     if (!isGitRepo(root))
@@ -199,7 +201,7 @@ program
     // and the store's JS-side reads/writes run synchronously between awaits (single
     // thread) — only the LLM spawns overlap. reindex() runs once, after the pool.
     await mapPool(commits, conc, async (sha) => {
-        const r = await syncCommit(store, root, sha);
+        const r = await syncCommit(store, root, sha, { deep: opts.deep });
         if (r.status === "written") {
             written++;
             if (r.provider === "claude-cli")
@@ -227,6 +229,8 @@ program
     .option("--quiet", "minimal output")
     .option("--force", "re-synthesize even if a decision already exists for the commit")
     .option("--private", "write the synthesized decision into the private overlay (HUNCH_PRIVATE_DIR), not the public repo — for a repo whose memory is kept private")
+    .option("--commit", "after a capture, also git add+commit+push the repo the decision landed in (opt-in; best-effort) — the private store under --private, else this repo")
+    .option("--deep", "Deep Synthesis: ensemble every available subscription CLI and reconcile their drafts (agreement-weighted, advisory). Slower; subscription-only")
     .action(async (sha, opts) => {
     const { store, root } = storeFor();
     if (!isGitRepo(root))
@@ -236,13 +240,27 @@ program
         return opts.quiet ? undefined : fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
     }
     store.json.ensureDirs();
-    const r = await syncCommit(store, root, sha ?? headSha(root), { force: opts.force, private: opts.private });
+    const r = await syncCommit(store, root, sha ?? headSha(root), { force: opts.force, private: opts.private, deep: opts.deep });
     if (r.status === "written") {
         store.reindex();
         // Don't rewrite CLAUDE.md from the hook — it would dirty the working tree
         // on every commit. `hunch index`/`init` refresh it intentionally instead.
         if (!opts.fromHook)
             updateClaudeMd(root, store);
+        // Opt-in: persist the captured decision in the repo it landed in (private store
+        // under --private, else this repo). Best-effort — a non-repo dir / offline push
+        // just no-ops. Stage ONLY the hunch dir (never sweep unrelated working-tree
+        // changes), and set HUNCH_SYNC=1 so the commit we create can't re-trigger this
+        // hook (no recursion, including on a manual `hunch sync --commit`).
+        const commitTarget = opts.commit ? (opts.private ? store.privateDir : hunchPaths(root).hunch) : undefined;
+        if (commitTarget) {
+            const g = (args) => { spawnSync("git", ["-C", commitTarget, ...args], { stdio: "ignore", env: { ...process.env, HUNCH_SYNC: "1" } }); };
+            g(["add", "--", "."]);
+            g(["commit", "-m", `hunch: capture ${r.decision?.id ?? "decision"}`]);
+            g(["push"]);
+            if (!opts.quiet)
+                console.log(`  ↳ committed + pushed ${r.decision?.id} (${commitTarget})`);
+        }
         if (!opts.quiet)
             console.log(`✓ captured decision ${r.decision?.id} via ${r.provider}: "${r.decision?.title}"`);
     }
@@ -257,6 +275,7 @@ program
     .description("Enable a PRIVATE memory overlay — sensitive decisions/bugs/constraints kept in a separate location, unioned into local queries, never committed here. Writes a gitignored .hunch/local.json so it's auto-detected (no env var needed).")
     .option("--repo <url>", "clone a private git repo to use as the store (into ./.hunch-private)")
     .option("--no-hook", "don't switch the post-commit hook to private sync")
+    .option("--auto-commit", "opt-in: the post-commit hook also git add+commit+pushes the private repo after each capture")
     .action((dir, opts) => {
     const root = findRoot();
     const paths = hunchPaths(root);
@@ -290,8 +309,8 @@ program
     let hookNote = "";
     if (opts.hook && isGitRepo(root)) {
         const inv = resolveInvocation();
-        const h = installPostCommitHook(root, inv.shell, { private: true });
-        hookNote = `  ✓ post-commit hook ${h.action} — captured decisions route here\n`;
+        const h = installPostCommitHook(root, inv.shell, { private: true, commit: opts.autoCommit });
+        hookNote = `  ✓ post-commit hook ${h.action} — captured decisions route here${opts.autoCommit ? " (auto-commit+push on)" : ""}\n`;
     }
     console.log(`✓ private overlay enabled → ${hunchDir}\n` +
         `  ✓ recorded in .hunch/local.json (gitignored) — auto-detected, no env var or shell-profile edit\n` +

package/dist/integrations/hooks.js

@@ -11,14 +11,16 @@ const MARK = "# >>> hunch post-commit >>>";
 const ENDMARK = "# <<< hunch post-commit <<<";
 function block(invocation, opts = {}) {
     // --private routes the auto-synthesized decision into the HUNCH_PRIVATE_DIR overlay
-    // instead of the public repo. The hook script is local (.git/hooks/), never committed,
-    // so a repo whose memory is kept private leaves no trace of this in the public tree.
+    // instead of the public repo. --commit (opt-in) also commits & pushes the repo the
+    // decision landed in (the private store under --private, else this repo). The hook
+    // script is local (.git/hooks/), never committed.
     const priv = opts.private ? " --private" : "";
+    const commit = opts.commit ? " --commit" : "";
     return [
         MARK,
         'if [ -z "$HUNCH_SYNC" ]; then',
         "  export HUNCH_SYNC=1",
-        `  ( ${invocation} sync --from-hook --quiet${priv} >/dev/null 2>&1 || true ) &`,
+        `  ( ${invocation} sync --from-hook --quiet${priv}${commit} >/dev/null 2>&1 || true ) &`,
         "fi",
         ENDMARK,
     ].join("\n");

package/dist/synthesis/provider.js

@@ -418,6 +418,95 @@ export async function selectProvider() {
     }
     return new DeterministicProvider();
 }
+// ---- Deep Synthesis: ensemble of subscription CLIs ------------------------
+// Opt-in (backfill/sync --deep): fan a commit out to EVERY available subscription
+// CLI, drop failures, and reconcile the drafts. Subscription-only (the workers are
+// the same CLI providers, so ANTHROPIC_API_KEY stripping is inherited). NEVER used on
+// the guard path; confidence is capped below the strict gate so output stays advisory.
+/** All available subscription-CLI workers (claude/codex/cursor), excluding the
+ *  deterministic fallback — the pool Deep Synthesis fans a commit out to. */
+export async function selectWorkers() {
+    const out = [];
+    for (const p of PROVIDERS) {
+        if (p.name === "deterministic")
+            continue; // workers are real subscription CLIs only
+        if (await isAvailable(p))
+            out.push(p);
+    }
+    return out;
+}
+const tokens = (d) => new Set(`${d.title} ${d.decision}`.toLowerCase().match(/[a-z0-9_]{3,}/g) ?? []);
+/** Mean pairwise Jaccard overlap of the drafts' identifying text (0..1) — how much the
+ *  independent workers AGREE. Drives the merged confidence. */
+function meanAgreement(drafts) {
+    if (drafts.length < 2)
+        return 1;
+    const sets = drafts.map(tokens);
+    let sum = 0, pairs = 0;
+    for (let i = 0; i < sets.length; i++)
+        for (let j = i + 1; j < sets.length; j++) {
+            const a = sets[i], b = sets[j];
+            let inter = 0;
+            for (const t of a)
+                if (b.has(t))
+                    inter++;
+            const union = a.size + b.size - inter;
+            sum += union ? inter / union : 0;
+            pairs++; // two empty drafts don't meaningfully "agree"
+        }
+    return pairs ? sum / pairs : 1;
+}
+const dedupLines = (xs) => [...new Set(xs.map((s) => s.trim()).filter(Boolean))];
+/** Reconcile N worker drafts into one. DETERMINISTIC (no second LLM call): the richest
+ *  draft is the spine; alternatives/consequences are unioned; confidence is AGREEMENT-
+ *  WEIGHTED and CAPPED at 0.78 — below STRICT_MIN_CONFIDENCE (0.8) — so an ensemble
+ *  auto-draft can never arm enforcement. */
+export function mergeDecisionDrafts(drafts) {
+    const primary = [...drafts].sort((a, b) => b.confidence - a.confidence || b.decision.length - a.decision.length)[0];
+    const agreement = meanAgreement(drafts);
+    return {
+        title: primary.title,
+        context: primary.context,
+        decision: primary.decision,
+        consequences: dedupLines(drafts.flatMap((d) => d.consequences)),
+        alternatives_rejected: dedupLines(drafts.flatMap((d) => d.alternatives_rejected)),
+        confidence: Math.min(0.78, 0.55 + 0.23 * agreement),
+        source: "llm_draft+ensemble",
+    };
+}
+export class EnsembleProvider {
+    workers;
+    name = "ensemble";
+    constructor(workers) {
+        this.workers = workers;
+    }
+    async available() { return this.workers.length > 0; }
+    async draftDecision(input) {
+        if (!this.workers.length)
+            throw new Error("ensemble: no subscription CLI workers available");
+        const settled = await Promise.allSettled(this.workers.map((w) => w.draftDecision(input)));
+        const drafts = settled.flatMap((s) => (s.status === "fulfilled" ? [s.value] : []));
+        if (!drafts.length)
+            throw new Error("ensemble: all workers failed");
+        return drafts.length === 1 ? drafts[0] : mergeDecisionDrafts(drafts);
+    }
+    async draftBug(input) {
+        // Bug ensembling is deferred — use the first worker that succeeds.
+        for (const w of this.workers) {
+            try {
+                return await w.draftBug(input);
+            }
+            catch { /* try next */ }
+        }
+        throw new Error("ensemble: all workers failed for bug");
+    }
+}
+/** Build the Deep-Synthesis provider, or null if no subscription CLI is available
+ *  (the caller then falls back to the normal single-provider path). */
+export async function selectEnsemble() {
+    const workers = await selectWorkers();
+    return workers.length ? new EnsembleProvider(workers) : null;
+}
 // ---- prompt + parsing helpers --------------------------------------------
 // Above this size we stop shipping the raw patch and lean on the deterministic
 // STRUCTURED CHANGES summary + a small sample. A truncated head-slice of a giant

package/dist/synthesis/synthesize.js

@@ -1,6 +1,6 @@
 import { commitMeta, commitDiff, headSha } from "../extractors/git.js";
 import { analyzeDiff } from "../extractors/diff.js";
-import { selectProvider, DeterministicProvider } from "./provider.js";
+import { selectProvider, selectEnsemble, DeterministicProvider } from "./provider.js";
 import { decisionId, bugId, constraintId } from "../core/ids.js";
 import { pathMatchesGlob } from "../core/glob.js";
 import { draftTripwires, knownRepoDeps } from "./tripwires.js";
@@ -66,9 +66,14 @@ export async function syncCommit(store, root, sha, opts = {}) {
     // Significance gate: reserve the paid LLM for substantive commits; trivial ones
     // get the FREE deterministic draft (honestly labeled "inferred"/low-confidence,
     // so the Hunch stays accurate-by-provenance). --force always uses the provider.
-    const provider = opts.force || isSignificant(meta, analysis, codeFiles)
-        ? await selectProvider()
-        : new DeterministicProvider();
+    // Deep Synthesis (--deep): ensemble every available subscription CLI and reconcile
+    // their drafts (agreement-weighted, confidence capped below the strict gate). Falls
+    // back to the normal single-provider path when no CLI is available. Opt-in only.
+    const provider = opts.deep
+        ? (await selectEnsemble()) ?? await selectProvider()
+        : opts.force || isSignificant(meta, analysis, codeFiles)
+            ? await selectProvider()
+            : new DeterministicProvider();
     const input = { subject: meta.subject, body: meta.body, files: codeFiles, diff, analysis };
     const draft = await draftDecisionSafe(provider, input);
     const components = store.json.loadAll("components");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
   "description": "Hunch — an Engineering Memory OS: a persistent, git-native reasoning graph over a codebase, exposed to Claude Code via MCP.",