lanekeeper 0.1.0 → 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/land.js

@@ -101,8 +101,13 @@ export async function land() {
                 // Landing isn't "done" until the checkout that actually serves your
                 // dev server can see it — call sync in-process rather than shelling
                 // back out to the CLI, so this doesn't depend on `lanekeeper` being
-                // resolvable on PATH.
-                exitCode = await sync();
+                // resolvable on PATH. Pass this lane's own already-loaded cfg through
+                // rather than letting sync() reload from MAIN — MAIN hasn't been
+                // fast-forwarded yet at this exact moment (that's what sync is about
+                // to do), so if this push just introduced or changed
+                // lanekeeper.config.mjs itself, a fresh MAIN-side load would silently
+                // fall back to DEFAULTS instead of the real config.
+                exitCode = await sync(cfg);
                 // Housekeeping, never a reason to fail this landing: sweep sibling
                 // lanes whose OWN branch already made it upstream (nothing created
                 // ever tears a worktree down on the way out) so they don't

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/dist/sync.d.ts

@@ -1,2 +1,16 @@
-/** Fast-forwards the MAIN checkout. Returns a process exit code; never throws. */
-export declare function sync(): Promise<number>;
+import { type LaneKeeperConfig } from "./lib/config.js";
+/**
+ * Fast-forwards the MAIN checkout. Returns a process exit code; never throws.
+ *
+ * Accepts an already-loaded config, for `land` calling this immediately
+ * after a push that ITSELF introduced or changed lanekeeper.config.mjs: the
+ * MAIN checkout hasn't been fast-forwarded yet at that exact moment (that's
+ * this function's whole job), so loading fresh from MAIN would silently
+ * fall back to DEFAULTS and could reject a perfectly good sync — the same
+ * bootstrap gap createLane had to be fixed for. The lane's own config,
+ * which just successfully rebased onto and pushed to the real
+ * integrationBranch, is the more trustworthy answer at that moment. A bare
+ * `lanekeeper sync` (no caller-provided config) still loads fresh from
+ * MAIN, same as before.
+ */
+export declare function sync(providedCfg?: LaneKeeperConfig): Promise<number>;

package/dist/sync.js

@@ -40,8 +40,21 @@ function sleep(ms) {
         /* tiny synchronous backoff for index.lock */
     }
 }
-/** Fast-forwards the MAIN checkout. Returns a process exit code; never throws. */
-export async function sync() {
+/**
+ * Fast-forwards the MAIN checkout. Returns a process exit code; never throws.
+ *
+ * Accepts an already-loaded config, for `land` calling this immediately
+ * after a push that ITSELF introduced or changed lanekeeper.config.mjs: the
+ * MAIN checkout hasn't been fast-forwarded yet at that exact moment (that's
+ * this function's whole job), so loading fresh from MAIN would silently
+ * fall back to DEFAULTS and could reject a perfectly good sync — the same
+ * bootstrap gap createLane had to be fixed for. The lane's own config,
+ * which just successfully rebased onto and pushed to the real
+ * integrationBranch, is the more trustworthy answer at that moment. A bare
+ * `lanekeeper sync` (no caller-provided config) still loads fresh from
+ * MAIN, same as before.
+ */
+export async function sync(providedCfg) {
     let MAIN;
     try {
         MAIN = resolveMainCheckout(process.cwd());
@@ -50,7 +63,7 @@ export async function sync() {
         console.error("lanekeeper sync: not inside a git repo — nothing to do.");
         return 0;
     }
-    const cfg = await loadConfig(MAIN);
+    const cfg = providedCfg ?? (await loadConfig(MAIN));
     const regenerable = new Set(cfg.regenerableFiles);
     const branchRes = git(MAIN, ["rev-parse", "--abbrev-ref", "HEAD"], { allowFail: true });
     const branch = branchRes.out.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeeper",
-  "version": "0.1.0",
+  "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",
@@ -8,7 +8,7 @@
   "homepage": "https://github.com/funador/lanekeeper",
   "repository": {
     "type": "git",
-    "url": "https://github.com/funador/lanekeeper.git"
+    "url": "git+https://github.com/funador/lanekeeper.git"
   },
   "keywords": [
     "claude-code",
@@ -20,7 +20,7 @@
     "monorepo-tooling"
   ],
   "bin": {
-    "lanekeeper": "./dist/bin/lanekeeper.js"
+    "lanekeeper": "dist/bin/lanekeeper.js"
   },
   "files": [
     "dist",