@davesheffer/hunch 0.17.3 → 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

@@ -186,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))
@@ -200,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")
@@ -229,6 +230,7 @@ program
     .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))
@@ -238,7 +240,7 @@ 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

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.3",
+  "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.",