@davesheffer/hunch 0.11.0 → 0.11.1

package/dist/cli/index.js

@@ -55,7 +55,7 @@ program
     .description("Scaffold .hunch/, index the repo, install the git hook, and wire up Claude Code.")
     .option("--no-index", "skip the initial repo index")
     .option("--no-enforce", "do not install the advisory pre-commit constraint guard")
-    .option("--enforce-strict", "make the pre-commit guard FAIL the commit on a blocking invariant (direct or near)")
+    .option("--enforce-strict", "make the pre-commit guard FAIL the commit on a direct, high-confidence, non-stale blocking invariant")
     .option("--no-providers", "skip scaffolding non-Claude assistant configs (Cursor / VS Code / Codex / AGENTS.md)")
     .option("--no-agent-hooks", "skip installing the Claude Code agent hooks (.claude/settings.json)")
     .option("--firmness <level>", "agent-hook firmness: off | advisory | firm | strict")
@@ -91,7 +91,7 @@ program
         if (opts.enforce !== false || opts.enforceStrict) {
             const strict = !!opts.enforceStrict;
             const p = installPreCommitHook(root, inv.shell, strict);
-            console.log(`  ✓ pre-commit constraint guard ${p.action} (${strict ? "strict — blocks on blocking invariants, direct or near" : "advisory — flags invariants in scope or blast radius"})`);
+            console.log(`  ✓ pre-commit constraint guard ${p.action} (${strict ? "strict — fails only on direct, high-confidence, non-stale blocking invariants" : "advisory — flags invariants in scope or blast radius"})`);
         }
     }
     else {
@@ -144,20 +144,39 @@ program
     store.close();
 });
 // ---- backfill -------------------------------------------------------------
+/** Run an async fn over items with at most `limit` in flight. A fixed pool of
+ *  workers pulls from a shared cursor — no per-batch barrier, so a slow item
+ *  never stalls the others. Used by backfill to overlap per-commit LLM spawns. */
+async function mapPool(items, limit, fn) {
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const i = next++;
+            await fn(items[i], i);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+}
 program
     .command("backfill")
     .description("Replay git history to seed decisions (cold-start fix).")
     .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")
     .action(async (opts) => {
     const { store, root } = storeFor();
     if (!isGitRepo(root))
         return fail("backfill needs a git repo");
     store.json.ensureDirs();
     const commits = logSince(opts.since, root, Number(opts.max));
-    console.log(`Backfilling from ${commits.length} commit(s) since ${opts.since}…`);
+    const conc = Math.max(1, Math.min(16, Number(opts.concurrency) || 4));
+    console.log(`Backfilling from ${commits.length} commit(s) since ${opts.since} (concurrency ${conc})…`);
     let written = 0, skipped = 0, llm = 0, heuristic = 0;
-    for (const sha of commits) {
+    // The per-commit cost is the Claude synthesis spawn; run several at once. Safe:
+    // each commit drafts independently and writes its OWN decision file atomically,
+    // 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);
         if (r.status === "written") {
             written++;
@@ -169,7 +188,7 @@ program
         }
         else
             skipped++;
-    }
+    });
     store.reindex();
     updateClaudeMd(root, store);
     // Honest tally of where the tokens went: trivial commits are seeded by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "license": "MIT",
   "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.",