lanekeeper 0.1.2 → 0.1.4

package/README.md

@@ -266,6 +266,19 @@ Things a sharp reader should already know before they ask:
   refuses to touch any worktree with a live process's cwd inside it right
   now. That check needs `lsof` on PATH; if it's missing, pruning fails
   closed (treats liveness as unknown, never removes) rather than guessing.
+- **The `WorktreeCreate` hook needs the host project's own real install.**
+  It runs via `npx lanekeeper hook worktree-create` (a raw hook command has
+  no `node_modules/.bin` on its PATH, unlike an `npm run` script) — but npx
+  silently falls back to fetching an ephemeral, unpinned copy when it can't
+  resolve the package locally, which is exactly what happens if the host
+  project's own `node_modules` install of lanekeeper is missing or
+  mid-upgrade. That's a real failure mode, not hypothetical: it happened in
+  production and the fallback ran silently long enough to mask a broken
+  install for two lane-landings. The hook now refuses to run at all if it
+  detects it's executing from npx's ephemeral cache rather than the
+  project's own installed copy, so a broken install fails loud immediately
+  (`npm install` and retry) instead of quietly limping along on a
+  mismatched stand-in version.
 
 ## 🧬 Where this came from
 

package/dist/hooks/worktree-create.d.ts

@@ -10,4 +10,5 @@ export declare function createLane(mainTop: string, cfg: LaneKeeperConfig): {
     branch: string;
     lane: number;
 };
+export declare function isEphemeralNpxCopy(selfPath: string): boolean;
 export declare function runWorktreeCreateHook(): Promise<void>;

package/dist/hooks/worktree-create.js

@@ -25,7 +25,8 @@
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, symlinkSync } from "node:fs";
-import { dirname, join, basename } from "node:path";
+import { dirname, join, basename, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { loadConfig, hasConfig, DEFAULTS } from "../lib/config.js";
 import { resolveMainCheckout } from "../lib/main-checkout.js";
 // A lane-claim loop with no upper bound is exactly one path-resolution bug
@@ -121,6 +122,24 @@ export function createLane(mainTop, cfg) {
         return { wt, branch, lane };
     }
 }
+// `.claude/settings.json` invokes this hook via `npx lanekeeper hook
+// worktree-create` rather than a project script, precisely because a raw
+// hook command has no `node_modules/.bin` on its PATH the way `npm run`
+// does — npx's own directory-walking local resolution is what makes that
+// work at all. The problem: npx treats a package it can't resolve locally as
+// license to silently fetch an ephemeral, unpinned copy from the registry
+// and run *that* instead of failing — which is exactly what happens when the
+// host project's own install of lanekeeper is missing or mid-upgrade (npm
+// removes the old version's files before extracting the new one; anything
+// that interrupts that leaves precisely this state). That fallback ran
+// silently for long enough in production to block two lanes from landing
+// before anyone noticed node_modules was broken. Refuse to proceed if this
+// module is executing from npx's ephemeral cache instead of the project's
+// own installed copy, so a broken install fails loud immediately instead of
+// limping along on a stand-in version nobody asked for.
+export function isEphemeralNpxCopy(selfPath) {
+    return selfPath.includes(`${sep}_npx${sep}`);
+}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -137,6 +156,10 @@ export async function runWorktreeCreateHook() {
     }
     const fromCwd = input.cwd ?? process.cwd();
     try {
+        if (isEphemeralNpxCopy(fileURLToPath(import.meta.url))) {
+            throw new Error("running from npx's ephemeral cache, not this project's own installed dependency — " +
+                "node_modules is missing or broken. Run `npm install` in the main checkout and try again.");
+        }
         const mainTop = resolveMainCheckout(fromCwd);
         const cfg = hasConfig(mainTop) ? await loadConfig(mainTop) : { ...DEFAULTS };
         const { wt } = createLane(mainTop, cfg);

package/dist/lib/prune-lanes.d.ts

@@ -5,4 +5,4 @@ import type { LaneKeeperConfig } from "./config.js";
  * worktree (dirty, diverged, busy) just skips that one; this never blocks
  * or fails the `land` it's running as part of.
  */
-export declare function pruneLandedLanes(mainTop: string, cfg: Pick<LaneKeeperConfig, "worktreeSuffix" | "branchPrefix" | "integrationBranch">, currentWorktree: string): string[];
+export declare function pruneLandedLanes(mainTop: string, cfg: Pick<LaneKeeperConfig, "worktreeSuffix" | "branchPrefix" | "integrationBranch" | "regenerableFiles">, currentWorktree: string): string[];

package/dist/lib/prune-lanes.js

@@ -26,7 +26,13 @@
  *      another lane's land before its own first commit.
  *   3. `git worktree remove` (no `--force`) refuses on its own if the
  *      worktree has uncommitted changes — dirty work is never discarded
- *      just because its branch happens to be merged.
+ *      just because its branch happens to be merged. The ONE exception,
+ *      matching `sync`/`land`: files listed in `regenerableFiles`
+ *      (next-env.d.ts and the like) are discarded first and the removal
+ *      retried, since a build tool rewriting its own output shouldn't be
+ *      the thing that leaves an otherwise fully-landed lane stuck forever.
+ *      Any OTHER dirty file blocks pruning exactly as before — real
+ *      uncommitted work is never discarded just to tidy up disk space.
  * Deleting the now-redundant local branch (`git branch -d`, never `-D`) is a
  * separate, best-effort tidiness step AFTER the worktree is already gone —
  * it checks merge state against local HEAD rather than origin, so it can
@@ -69,6 +75,15 @@ function existsRealpath(path) {
         return path;
     }
 }
+function tryRemoveWorktree(mainTop, wt) {
+    try {
+        execFileSync("git", ["worktree", "remove", wt], { cwd: mainTop, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function listWorktrees(mainTop) {
     const out = execFileSync("git", ["worktree", "list", "--porcelain"], { cwd: mainTop, encoding: "utf8" });
     const entries = [];
@@ -109,6 +124,7 @@ export function pruneLandedLanes(mainTop, cfg, currentWorktree) {
     const laneDirPrefix = `${basename(mainTopReal)}${cfg.worktreeSuffix}`;
     const parent = dirname(mainTopReal);
     const upstream = `origin/${cfg.integrationBranch}`;
+    const regenerable = new Set(cfg.regenerableFiles);
     let worktrees;
     try {
         worktrees = listWorktrees(mainTop);
@@ -134,12 +150,23 @@ export function pruneLandedLanes(mainTop, cfg, currentWorktree) {
         }
         if (hasLiveProcessInside(wt))
             continue; // someone's actively in here — never touch it
-        try {
-            execFileSync("git", ["worktree", "remove", wt], { cwd: mainTop, stdio: "ignore" });
-        }
-        catch {
-            continue; // dirty or busy — worktree remove refused on its own, nothing removed
+        let removed = tryRemoveWorktree(mainTop, wt);
+        if (!removed) {
+            // Blocked by dirty files? Only retry if EVERY one of them is a
+            // configured regenerable file — anything else is real uncommitted
+            // work, and this lane is left alone exactly as before.
+            const dirty = execFileSync("git", ["status", "--porcelain"], { cwd: wt, encoding: "utf8" })
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => line.slice(3).trim());
+            const blocking = dirty.filter((f) => !regenerable.has(f));
+            if (dirty.length > 0 && blocking.length === 0) {
+                execFileSync("git", ["checkout", "--", ...dirty], { cwd: wt, stdio: "ignore" });
+                removed = tryRemoveWorktree(mainTop, wt);
+            }
         }
+        if (!removed)
+            continue; // still dirty (real work) or otherwise busy — leave it alone
         // The worktree is gone — this is now unconditionally a pruned lane,
         // regardless of what happens to the branch ref below.
         pruned.push(wt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeeper",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The local, zero-cost merge queue for parallel Claude Code agents. Plugs into Claude Code's native worktree isolation; one build at a time, one landing at a time, zero races.",
   "type": "module",
   "license": "MIT",