@davesheffer/hunch 0.33.1 → 0.34.0

package/dist/cli/index.js

@@ -35,6 +35,7 @@ import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkrepo
 import { partitionReview, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
 import { ensureSharedOverlayPointer } from "../integrations/worktree.js";
+import { flushPrivate } from "../integrations/sync.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS } from "../integrations/gitignore.js";
 import { writeCiWorkflow } from "../integrations/ciAction.js";
@@ -312,7 +313,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: also git add+commit+push the private repo after each capture (post-commit hook AND MCP private writes)")
+    .option("--no-auto-commit", "DON'T auto commit+push the overlay after each capture (default: ON — fully automated two-way sync, never push by hand)")
     .option("--sync", "flush the configured private store now (git add+commit+push) — catches records made via MCP between commits")
     .option("--migrate", "ONE-TIME: move this repo's EXISTING public .hunch memory into the overlay, then make the public repo code-only — untrack + gitignore the memory tree and regenerate grounding so no memory is published here")
     .action((dir, opts) => {
@@ -344,6 +345,13 @@ program
     }
     // 2) create the layout (decisions/, manifest, …) so it's queryable immediately
     new JsonStore(hunchPathsForDir(hunchDir)).ensureDirs();
+    const inv = resolveInvocation();
+    // Install the structured merge driver IN the overlay repo so concurrent captures from
+    // multiple machines/worktrees merge by RECORD ID (no manual conflict resolution) when the
+    // two-way auto-sync pulls before pushing. The overlay repo root is the parent of its .hunch.
+    const overlayRoot = hunchPathsForDir(hunchDir).root;
+    if (isGitRepo(overlayRoot))
+        installMergeDriver(overlayRoot, inv.shell);
     // 3) record the path in a GITIGNORED local config — auto-detected, no env var, and
     //    the MCP server picks it up too. Atomic write (con_902759b3dc) since it's under .hunch/.
     mkdirSync(paths.hunch, { recursive: true }); // tolerate a repo where `hunch init` hasn't run yet
@@ -365,7 +373,6 @@ program
     // 4) route post-commit synthesis to the overlay (local hook, never committed)
     let hookNote = "";
     if (opts.hook && isGitRepo(root)) {
-        const inv = resolveInvocation();
         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`;
     }
@@ -674,6 +681,8 @@ program
         }
     }
     store.reindex();
+    if (opts.private && (dec || con))
+        flushPrivate(store, `hunch: capture ${dec + con} inline intent(s)`);
     if (!intents.length)
         console.log("No `hunch-why:` / `hunch-rule:` comments found.");
     else

package/dist/extractors/git.js

@@ -44,7 +44,51 @@ export function commitAndPushHunch(hunchDir, message) {
         };
         run(["add", "--", "."]);
         run(["commit", "-m", message]);
-        run(["push"]);
+        // Two-way sync: MERGE the remote BEFORE pushing, so a push can never be rejected
+        // non-fast-forward (the cause of memory piling up unpushed across machines). The .hunch
+        // merge driver resolves same-record conflicts by id; non-overlapping records merge cleanly
+        // without it. On an unresolved conflict / offline, mergeRemote aborts to a clean tree and we
+        // skip the push — the local commit stays and syncs on the next write (never lost).
+        if (mergeRemote(hunchDir, env))
+            run(["push"]);
+    }
+    finally {
+        try {
+            rmSync(lock, { recursive: true, force: true });
+        }
+        catch { /* released best-effort */ }
+    }
+}
+/** Merge the overlay's remote into the local branch (pull, no rebase), leaving a CLEAN tree
+ *  whether it succeeds or not. Returns true when the branch is safe to push (merged, or there's
+ *  no upstream to merge), false when a conflict was aborted (caller skips the push and retries
+ *  on the next write). Never throws. */
+function mergeRemote(hunchDir, env) {
+    const tryGit = (args) => {
+        try {
+            execFileSync("git", ["-C", hunchDir, ...args], { stdio: "ignore", env });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!tryGit(["rev-parse", "--abbrev-ref", "@{upstream}"]))
+        return true; // no remote/offline → push no-ops
+    if (tryGit(["pull", "--no-edit", "--no-rebase", "--autostash"]))
+        return true;
+    tryGit(["merge", "--abort"]); // conflict the driver couldn't resolve → restore a clean tree
+    return false;
+}
+/** Best-effort READ-side sync: merge the overlay's remote into the local branch (e.g. on MCP
+ *  server start) so this machine/session sees other machines' memory. Never throws; leaves a
+ *  clean tree. Serialized with the commit lock so it can't race a concurrent flush. */
+export function pullHunch(hunchDir) {
+    const lock = join(hunchDir, ".hunch-commit.lock");
+    if (!acquireCommitLock(lock))
+        return;
+    try {
+        mergeRemote(hunchDir, { ...process.env, HUNCH_SYNC: "1" });
     }
     finally {
         try {

package/dist/integrations/sync.js

@@ -0,0 +1,8 @@
+import { commitAndPushHunch } from "../extractors/git.js";
+/** Auto-commit + push the overlay after a private write, when auto-commit is on. No-op
+ *  otherwise (manual `hunch private --sync` still works). Never throws. */
+export function flushPrivate(store, message) {
+    if (store.privateAutoCommit && store.privateDir)
+        commitAndPushHunch(store.privateDir, message);
+}
+//# sourceMappingURL=sync.js.map

package/dist/mcp/server.js

@@ -14,7 +14,7 @@ import { HunchStore } from "../store/hunchStore.js";
 import { selectEmbedder } from "../store/embedder.js";
 import { decisionId } from "../core/ids.js";
 import { buildCorrectionConstraint } from "../core/correction.js";
-import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch } from "../extractors/git.js";
+import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch, pullHunch } from "../extractors/git.js";
 import { formatContext } from "../core/format.js";
 import { compareCandidates } from "../core/compare.js";
 import { checkConformance } from "../core/conformance.js";
@@ -52,6 +52,15 @@ function resolveFiles(store, target) {
 }
 export function buildServer(root) {
     const store = new HunchStore(hunchPaths(root));
+    // Two-way sync (read side): pull the private overlay's remote on startup, so THIS machine's
+    // session sees memory captured on other machines/worktrees before we index — making the
+    // overlay genuinely one source of truth. Best-effort, leaves a clean tree, never blocks start.
+    if (store.privateDir) {
+        try {
+            pullHunch(store.privateDir);
+        }
+        catch { /* offline / no remote — proceed with local */ }
+    }
     // Ensure the SQLite index reflects the JSON source of truth on startup.
     try {
         store.reindex();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.33.1",
+  "version": "0.34.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.",