lanekeeper 0.1.1 → 0.1.2

package/README.md

@@ -60,6 +60,7 @@ locally instead of in someone else's billed cloud. 💸
 | `lanekeeper promote` | Ships the integration branch to production. **Human-only** — never in an agent's instructions, never automated. |
 | `lanekeeper preview` | Instantly mirrors a lane's live working tree — uncommitted changes included — onto the main checkout, so you can look at it without a build. |
 | `lanekeeper port` | Prints a lane's dev-server port, derived from its own directory name. |
+| `lanekeeper prune` | Removes already-landed sibling lane worktrees on demand — `land` already does this automatically, this is for "clean these up right now" instead of waiting for the next lane to land something. |
 
 Plus 🔒 a pre-push hook that makes `land` non-optional: a direct `git push`
 straight to the integration branch gets bounced, full stop. Not a lint
@@ -259,6 +260,12 @@ Things a sharp reader should already know before they ask:
   CLAUDE.md tells it to resolve the conflict itself and re-run `land`, the
   same way it'd fix any other bug — `checkCommand` still gates the result
   either way, so a bad resolution gets caught there.
+- **Auto-pruning checks for a live process, via `lsof`.** A merged branch
+  alone isn't enough to prune a lane — a brand-new, zero-commit lane is
+  *trivially* "merged" too (nothing's diverged yet), so pruning also
+  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.
 
 ## 🧬 Where this came from
 

package/dist/bin/lanekeeper.js

@@ -17,6 +17,8 @@ import { lanePort } from "../lib/lane-port.js";
 import { claudeMdSnippet, MARKER } from "../lib/claude-md-snippet.js";
 import { detectCheckCommand, runCheckCommand } from "../lib/check-command.js";
 import { wireClaudeSettings, wireHuskyPrePush, ensureHooksPath } from "../lib/wire-hooks.js";
+import { resolveMainCheckout } from "../lib/main-checkout.js";
+import { pruneLandedLanes } from "../lib/prune-lanes.js";
 const [, , command, ...rest] = process.argv;
 async function readStdin() {
     const chunks = [];
@@ -180,6 +182,30 @@ async function main() {
         case "promote":
             process.exit(await promote());
             return;
+        case "prune": {
+            // `land` already does this automatically as a side effect of every
+            // successful landing — this is the on-demand escape hatch for
+            // "clean these up right now" instead of waiting for the next lane to
+            // land something. Same safety rules apply: only already-merged
+            // branches, never anything with a live process inside, never the
+            // worktree this command itself is running from.
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                console.error("lanekeeper prune: no lanekeeper.config found — nothing to do.");
+                process.exit(0);
+            }
+            const cfg = await loadConfig(root);
+            const mainTop = resolveMainCheckout(process.cwd());
+            const pruned = pruneLandedLanes(mainTop, cfg, process.cwd());
+            if (pruned.length === 0) {
+                console.log("lanekeeper prune: nothing to clean up — no already-landed sibling lanes found.");
+            }
+            else {
+                const names = pruned.map((p) => p.split("/").pop()).join(", ");
+                console.log(`lanekeeper prune: removed ${pruned.length} already-landed lane${pruned.length === 1 ? "" : "s"}: ${names}`);
+            }
+            return;
+        }
         case "preview":
             return runPreview(rest);
         case "build-lock": {

package/dist/lib/prune-lanes.js

@@ -14,7 +14,17 @@
  *      fast-forwarded yet at the exact moment this runs. That's the literal
  *      definition of "nothing to lose": the work already made it upstream
  *      under its own name.
- *   2. `git worktree remove` (no `--force`) refuses on its own if the
+ *   2. Never touch a worktree with a LIVE process currently working in it
+ *      (checked via `lsof -a -d cwd`, see below) — this is NOT redundant
+ *      with the ancestor check. A brand-new lane that hasn't diverged yet
+ *      is *trivially* an ancestor of upstream (its tip IS a commit already
+ *      on the integration branch, just because nothing's been committed
+ *      there yet) — structurally identical, in the git graph alone, to a
+ *      lane whose own real work already landed. Only a liveness check can
+ *      tell "someone's about to start working here" apart from "this is
+ *      truly done." Confirmed live: a fresh, zero-commit lane got swept by
+ *      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.
  * Deleting the now-redundant local branch (`git branch -d`, never `-D`) is a
@@ -24,9 +34,31 @@
  * That failure doesn't undo the (already-safe) worktree removal or keep it
  * out of the returned list; it just leaves a harmless leftover branch ref.
  */
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { basename, dirname } from "node:path";
+/**
+ * Is any live process's current working directory inside `dir` right now?
+ * `lsof`'s own exit code is NOT reliable for this — it returns non-zero
+ * both when nothing matches AND when it merely fails to inspect some
+ * unrelated process it lacks permission for (common, e.g. root-owned system
+ * daemons), even while correctly printing real matches. The trustworthy
+ * signal is whether stdout has any content at all: genuinely idle
+ * directories produce completely empty output; a live process's cwd entry
+ * always prints a real row. `-a` ANDs the two filters together (lsof ORs by
+ * default) so this only matches things actually inside `dir`, not every
+ * process on the system.
+ *
+ * If `lsof` isn't available at all, this fails CLOSED — treats liveness as
+ * unknown/possible rather than confirmed-safe, so an unverifiable state
+ * never gets treated the same as a verified-idle one.
+ */
+function hasLiveProcessInside(dir) {
+    const result = spawnSync("lsof", ["-a", "-d", "cwd", "+D", dir], { encoding: "utf8" });
+    if (result.error)
+        return true; // lsof missing/unspawnable — can't verify, assume in use
+    return result.stdout.trim().length > 0;
+}
 // Best-effort realpath — a "current worktree" that's already gone (or was
 // never real to begin with) shouldn't crash the sweep over one path.
 function existsRealpath(path) {
@@ -100,6 +132,8 @@ export function pruneLandedLanes(mainTop, cfg, currentWorktree) {
         catch {
             continue; // not safe to touch — leave this lane exactly as it is
         }
+        if (hasLiveProcessInside(wt))
+            continue; // someone's actively in here — never touch it
         try {
             execFileSync("git", ["worktree", "remove", wt], { cwd: mainTop, stdio: "ignore" });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeeper",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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",