claude-code-merge-queue 0.1.14

package/dist/bin/lanekeeper.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/**
+ * The lanekeeper CLI. Every subcommand reads lanekeeper.config from the
+ * current repo — see src/lib/config.ts — so none of this is hardcoded to
+ * any one project's branch names.
+ */
+import { readFileSync } from "node:fs";
+import { land } from "../land.js";
+import { sync } from "../sync.js";
+import { promote } from "../promote.js";
+import { runPreview } from "../preview.js";
+import { buildLock } from "../build-lock.js";
+import { findRepoRoot, hasConfig, loadConfig, detectCurrentBranch, DEFAULTS } from "../lib/config.js";
+import { checkPush, parseRefUpdates } from "../lib/check-push.js";
+import { runWorktreeCreateHook } from "../hooks/worktree-create.js";
+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, wirePackageJsonScripts } 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 = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function init() {
+    const root = findRepoRoot();
+    if (!root) {
+        console.error("lanekeeper init: not inside a git repo.");
+        process.exit(1);
+    }
+    const { writeFileSync, readFileSync: read, existsSync, appendFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    // What actually got newly written or modified this run — only these need
+    // committing. If everything below was already wired from a previous run,
+    // there's nothing new to tell you to commit.
+    const writtenFiles = [];
+    if (hasConfig(root)) {
+        console.log("lanekeeper init: lanekeeper.config.mjs already exists — leaving it alone.");
+    }
+    else {
+        writtenFiles.push("lanekeeper.config.mjs");
+        const detectedBranch = detectCurrentBranch(root);
+        const detectedCheck = detectCheckCommand(root);
+        const generated = {
+            ...DEFAULTS,
+            ...(detectedBranch ? { integrationBranch: detectedBranch } : {}),
+            ...(detectedCheck ? { checkCommand: detectedCheck } : {}),
+        };
+        const template = `// lanekeeper.config.mjs — generated by \`lanekeeper init\`. Edit freely.
+// Its presence here is what turns LaneKeeper ON for this repo.
+
+/** @type {import("lanekeeper").LaneKeeperConfig} */
+export default ${JSON.stringify(generated, null, 2)};
+`;
+        writeFileSync(join(root, "lanekeeper.config.mjs"), template);
+        console.log(`lanekeeper init: wrote ${join(root, "lanekeeper.config.mjs")}`);
+        if (detectedBranch && detectedBranch !== DEFAULTS.integrationBranch) {
+            console.log(`  (detected current branch "${detectedBranch}" — set as integrationBranch instead of the "${DEFAULTS.integrationBranch}" default)`);
+        }
+        else if (!detectedBranch) {
+            console.log("");
+            console.log(`  ⚠️  Couldn't detect the current branch (detached HEAD?) — integrationBranch`);
+            console.log(`      defaulted to "${DEFAULTS.integrationBranch}". Verify that's actually right`);
+            console.log(`      in lanekeeper.config.mjs before committing it.`);
+        }
+        if (detectedCheck) {
+            console.log(`  (detected "${detectedCheck}" from package.json — set as checkCommand)`);
+        }
+        else {
+            console.log("");
+            console.log("  ⚠️  No checkCommand detected (no check:push/check/ci/test script found in");
+            console.log("      package.json). Every push is BLOCKED until you set one — or set");
+            console.log("      checksRequired: false to deliberately run with no checks.");
+        }
+    }
+    // This is the part that actually makes agents use the workflow without a
+    // human reminding them every session — see claude-md-snippet.ts.
+    const claudeMdPath = join(root, "CLAUDE.md");
+    const cfg = hasConfig(root) ? await loadConfig(root) : DEFAULTS;
+    const snippet = claudeMdSnippet(cfg);
+    if (!existsSync(claudeMdPath)) {
+        writeFileSync(claudeMdPath, `# Project instructions for Claude Code\n\n${snippet}`);
+        console.log(`lanekeeper init: wrote ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
+    }
+    else if (!read(claudeMdPath, "utf8").includes(MARKER)) {
+        appendFileSync(claudeMdPath, `\n${snippet}`);
+        console.log(`lanekeeper init: appended the LaneKeeper workflow section to ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
+    }
+    else {
+        console.log(`lanekeeper init: ${claudeMdPath} already has the LaneKeeper workflow section — leaving it alone.`);
+    }
+    const claudeSettingsResult = wireClaudeSettings(root);
+    switch (claudeSettingsResult) {
+        case "created":
+            console.log(`lanekeeper init: wrote ${join(root, ".claude", "settings.json")} with the WorktreeCreate hook.`);
+            writtenFiles.push(".claude/settings.json");
+            break;
+        case "merged":
+            console.log(`lanekeeper init: added the WorktreeCreate hook to your existing ${join(root, ".claude", "settings.json")}.`);
+            writtenFiles.push(".claude/settings.json");
+            break;
+        case "already-wired":
+            console.log("lanekeeper init: .claude/settings.json already has the WorktreeCreate hook — leaving it alone.");
+            break;
+        case "unparseable":
+            console.log("lanekeeper init: .claude/settings.json exists but isn't valid JSON — left untouched. Wire it manually,");
+            console.log("  see node_modules/lanekeeper/hooks/claude-settings.example.json.");
+            break;
+    }
+    const prePushResult = wireHuskyPrePush(root);
+    switch (prePushResult) {
+        case "created":
+            console.log("lanekeeper init: wrote .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
+            break;
+        case "merged":
+            console.log("lanekeeper init: appended LaneKeeper's checks to your existing .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
+            break;
+        case "already-wired":
+            console.log("lanekeeper init: .husky/pre-push already wired — leaving it alone.");
+            break;
+        case "no-husky":
+            console.log("lanekeeper init: no .husky/ directory found — pre-push hook NOT wired automatically.");
+            console.log("  Install Husky, or copy node_modules/lanekeeper/hooks/pre-push to .git/hooks/pre-push");
+            console.log("  yourself (note: .git/hooks isn't version-controlled — only Husky's is shared with your team).");
+            break;
+    }
+    if (prePushResult === "created" || prePushResult === "merged" || prePushResult === "already-wired") {
+        // A .husky/pre-push file enforces nothing until core.hooksPath actually
+        // points at .husky — normally a side effect of the package manager's
+        // install step, which may not have run yet (e.g. a fresh clone, right
+        // where Quickstart leaves you). Without this, a direct push sails
+        // through uncontested with no indication anything's wrong.
+        switch (ensureHooksPath(root)) {
+            case "set":
+                console.log("lanekeeper init: set core.hooksPath=.husky so the pre-push hook actually runs (normally set by your package manager's install step, which may not have run yet).");
+                break;
+            case "already-set":
+                break; // the common case once installed — nothing to say
+            case "custom-path":
+                console.log("lanekeeper init: core.hooksPath is set to something other than .husky — leaving it alone.");
+                console.log("  Wrote .husky/pre-push, but it won't run until your hooks path points there. Reconcile this yourself.");
+                break;
+        }
+    }
+    const scriptsResult = wirePackageJsonScripts(root);
+    switch (scriptsResult.result) {
+        case "added":
+            console.log(`lanekeeper init: added "${scriptsResult.added.join('", "')}" to package.json scripts.`);
+            writtenFiles.push("package.json");
+            break;
+        case "already-wired":
+            console.log("lanekeeper init: package.json already has all five scripts — leaving them alone.");
+            break;
+        case "no-package-json":
+            console.log("lanekeeper init: no package.json found — scripts NOT wired automatically.");
+            console.log('  Add "land"/"sync"/"promote"/"preview"/"preview:restore" -> "lanekeeper <name>" yourself.');
+            break;
+        case "unparseable":
+            console.log("lanekeeper init: package.json exists but isn't valid JSON — left untouched. Wire the scripts manually.");
+            break;
+    }
+    console.log("");
+    console.log("Next steps:");
+    if (writtenFiles.length > 0) {
+        console.log(`  1. Commit what it wrote — ${writtenFiles.join(", ")}.`);
+        console.log("  2. claude --worktree <name> — the agent takes it from there.");
+    }
+    else {
+        console.log("  1. claude --worktree <name> — the agent takes it from there.");
+        console.log("     (everything was already wired — nothing new to commit)");
+    }
+}
+async function main() {
+    switch (command) {
+        case "init":
+            return init();
+        case "hook": {
+            const sub = rest[0];
+            if (sub === "worktree-create")
+                return runWorktreeCreateHook();
+            console.error(`lanekeeper hook: unknown hook "${sub ?? ""}". Only "worktree-create" is supported.`);
+            process.exit(1);
+            return;
+        }
+        case "port": {
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                console.error("lanekeeper port: no lanekeeper.config found — not a lane.");
+                process.exit(1);
+            }
+            const cfg = await loadConfig(root);
+            const port = lanePort(process.cwd(), cfg);
+            if (port === null) {
+                console.error("lanekeeper port: current directory doesn't look like a lane worktree.");
+                process.exit(1);
+            }
+            console.log(port);
+            return;
+        }
+        case "land":
+            return land();
+        case "sync":
+            process.exit(await sync());
+            return;
+        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": {
+            const parts = rest[0] === "--" ? rest.slice(1) : rest;
+            return buildLock(parts);
+        }
+        case "check-push": {
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                // No config means LaneKeeper isn't enabled for this repo — nothing to enforce.
+                process.exit(0);
+            }
+            const cfg = await loadConfig(root);
+            const stdin = await readStdin();
+            const refUpdates = parseRefUpdates(stdin);
+            // git still invokes pre-push (with empty stdin) for a push that
+            // updates zero refs — e.g. re-pushing a branch that's already exactly
+            // up to date on the remote. There's nothing to block (nothing is
+            // actually changing on the remote either way) and nothing meaningful
+            // for checkCommand to verify — running it anyway just produces a
+            // confusing, unrelated failure (a missing devDependency, say) that
+            // looks exactly like a real block but isn't one. Recognize "nothing
+            // to push" explicitly instead of silently falling through both checks.
+            if (refUpdates.length === 0) {
+                console.log("lanekeeper check-push: nothing being pushed (already up to date) — skipping checks.");
+                process.exit(0);
+            }
+            if (process.env.LANEKEEPER_EMERGENCY_PUSH === "1") {
+                console.log("\n🚨 LANEKEEPER_EMERGENCY_PUSH is set — bypassing the landing queue.\n");
+            }
+            const result = checkPush(refUpdates, cfg, process.env);
+            if (!result.ok) {
+                console.error(result.message);
+                process.exit(1);
+            }
+            process.exit(runCheckCommand(cfg, root));
+            return;
+        }
+        case "--version":
+        case "-v": {
+            const { join, dirname } = await import("node:path");
+            const { fileURLToPath } = await import("node:url");
+            const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            console.log(pkg.version);
+            return;
+        }
+        default:
+            console.log(`lanekeeper — keep parallel coding agents in their lane.
+
+Usage:
+  lanekeeper init                  write a starter lanekeeper.config.mjs
+  lanekeeper land                  rebase + push this lane onto the integration branch (queued)
+  lanekeeper sync                  fast-forward the MAIN checkout to its upstream
+  lanekeeper promote               ship the integration branch to production (human-only — never script this)
+  lanekeeper preview [--restore]   swap the MAIN checkout to this lane's working tree, or restore it
+  lanekeeper build-lock -- <cmd>   run <cmd>, serialized across every lane
+  lanekeeper port                  print this lane's dev-server port
+  lanekeeper hook worktree-create  (Claude Code WorktreeCreate hook — not for direct use)
+  lanekeeper check-push            (used by the pre-push hook — not for direct use)
+`);
+            process.exit(command ? 1 : 0);
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/bin/localmerge.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/localmerge.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * The localmerge CLI. Every subcommand reads localmerge.config from the
+ * current repo — see src/lib/config.ts — so none of this is hardcoded to
+ * any one project's branch names.
+ */
+import { readFileSync } from "node:fs";
+import { land } from "../land.js";
+import { sync } from "../sync.js";
+import { promote } from "../promote.js";
+import { runPreview } from "../preview.js";
+import { buildLock } from "../build-lock.js";
+import { findRepoRoot, hasConfig, loadConfig, detectCurrentBranch, DEFAULTS } from "../lib/config.js";
+import { checkPush, parseRefUpdates } from "../lib/check-push.js";
+import { runWorktreeCreateHook } from "../hooks/worktree-create.js";
+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, wirePackageJsonScripts, wirePreflightScript, PREFLIGHT_FILENAME } 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 = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function init() {
+    const root = findRepoRoot();
+    if (!root) {
+        console.error("localmerge init: not inside a git repo.");
+        process.exit(1);
+    }
+    const { writeFileSync, readFileSync: read, existsSync, appendFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    // What actually got newly written or modified this run — only these need
+    // committing. If everything below was already wired from a previous run,
+    // there's nothing new to tell you to commit.
+    const writtenFiles = [];
+    if (hasConfig(root)) {
+        console.log("localmerge init: localmerge.config.mjs already exists — leaving it alone.");
+    }
+    else {
+        writtenFiles.push("localmerge.config.mjs");
+        const detectedBranch = detectCurrentBranch(root);
+        const detectedCheck = detectCheckCommand(root);
+        const generated = {
+            ...DEFAULTS,
+            ...(detectedBranch ? { integrationBranch: detectedBranch } : {}),
+            ...(detectedCheck ? { checkCommand: detectedCheck } : {}),
+        };
+        const template = `// localmerge.config.mjs — generated by \`localmerge init\`. Edit freely.
+// Its presence here is what turns LocalMerge ON for this repo.
+
+/** @type {import("localmerge").LocalMergeConfig} */
+export default ${JSON.stringify(generated, null, 2)};
+`;
+        writeFileSync(join(root, "localmerge.config.mjs"), template);
+        console.log(`localmerge init: wrote ${join(root, "localmerge.config.mjs")}`);
+        if (detectedBranch && detectedBranch !== DEFAULTS.integrationBranch) {
+            console.log(`  (detected current branch "${detectedBranch}" — set as integrationBranch instead of the "${DEFAULTS.integrationBranch}" default)`);
+        }
+        else if (!detectedBranch) {
+            console.log("");
+            console.log(`  ⚠️  Couldn't detect the current branch (detached HEAD?) — integrationBranch`);
+            console.log(`      defaulted to "${DEFAULTS.integrationBranch}". Verify that's actually right`);
+            console.log(`      in localmerge.config.mjs before committing it.`);
+        }
+        if (detectedCheck) {
+            console.log(`  (detected "${detectedCheck}" from package.json — set as checkCommand)`);
+        }
+        else {
+            console.log("");
+            console.log("  ⚠️  No checkCommand detected (no check:push/check/ci/test script found in");
+            console.log("      package.json). Every push is BLOCKED until you set one — or set");
+            console.log("      checksRequired: false to deliberately run with no checks.");
+        }
+    }
+    // This is the part that actually makes agents use the workflow without a
+    // human reminding them every session — see claude-md-snippet.ts.
+    const claudeMdPath = join(root, "CLAUDE.md");
+    const cfg = hasConfig(root) ? await loadConfig(root) : DEFAULTS;
+    const snippet = claudeMdSnippet(cfg);
+    if (!existsSync(claudeMdPath)) {
+        writeFileSync(claudeMdPath, `# Project instructions for Claude Code\n\n${snippet}`);
+        console.log(`localmerge init: wrote ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
+    }
+    else if (!read(claudeMdPath, "utf8").includes(MARKER)) {
+        appendFileSync(claudeMdPath, `\n${snippet}`);
+        console.log(`localmerge init: appended the LocalMerge workflow section to ${claudeMdPath}`);
+        writtenFiles.push("CLAUDE.md");
+    }
+    else {
+        console.log(`localmerge init: ${claudeMdPath} already has the LocalMerge workflow section — leaving it alone.`);
+    }
+    const claudeSettingsResult = wireClaudeSettings(root);
+    switch (claudeSettingsResult) {
+        case "created":
+            console.log(`localmerge init: wrote ${join(root, ".claude", "settings.json")} with the WorktreeCreate hook.`);
+            writtenFiles.push(".claude/settings.json");
+            break;
+        case "merged":
+            console.log(`localmerge init: added the WorktreeCreate hook to your existing ${join(root, ".claude", "settings.json")}.`);
+            writtenFiles.push(".claude/settings.json");
+            break;
+        case "already-wired":
+            console.log("localmerge init: .claude/settings.json already has the WorktreeCreate hook — leaving it alone.");
+            break;
+        case "unparseable":
+            console.log("localmerge init: .claude/settings.json exists but isn't valid JSON — left untouched. Wire it manually,");
+            console.log("  see node_modules/localmerge/hooks/claude-settings.example.json.");
+            break;
+    }
+    const prePushResult = wireHuskyPrePush(root);
+    switch (prePushResult) {
+        case "created":
+            console.log("localmerge init: wrote .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
+            break;
+        case "merged":
+            console.log("localmerge init: appended LocalMerge's checks to your existing .husky/pre-push.");
+            writtenFiles.push(".husky/pre-push");
+            break;
+        case "already-wired":
+            console.log("localmerge init: .husky/pre-push already wired — leaving it alone.");
+            break;
+        case "no-husky":
+            console.log("localmerge init: no .husky/ directory found — pre-push hook NOT wired automatically.");
+            console.log("  Install Husky, or copy node_modules/localmerge/hooks/pre-push to .git/hooks/pre-push");
+            console.log("  yourself (note: .git/hooks isn't version-controlled — only Husky's is shared with your team).");
+            break;
+    }
+    if (prePushResult === "created" || prePushResult === "merged" || prePushResult === "already-wired") {
+        // A .husky/pre-push file enforces nothing until core.hooksPath actually
+        // points at .husky — normally a side effect of the package manager's
+        // install step, which may not have run yet (e.g. a fresh clone, right
+        // where Quickstart leaves you). Without this, a direct push sails
+        // through uncontested with no indication anything's wrong.
+        switch (ensureHooksPath(root)) {
+            case "set":
+                console.log("localmerge init: set core.hooksPath=.husky so the pre-push hook actually runs (normally set by your package manager's install step, which may not have run yet).");
+                break;
+            case "already-set":
+                break; // the common case once installed — nothing to say
+            case "custom-path":
+                console.log("localmerge init: core.hooksPath is set to something other than .husky — leaving it alone.");
+                console.log("  Wrote .husky/pre-push, but it won't run until your hooks path points there. Reconcile this yourself.");
+                break;
+        }
+    }
+    switch (wirePreflightScript(root, cfg.integrationBranch)) {
+        case "created":
+            console.log(`localmerge init: wrote ${PREFLIGHT_FILENAME} (a self-contained pre-check "land"/"sync" run before landing — see comments in the file).`);
+            writtenFiles.push(PREFLIGHT_FILENAME);
+            break;
+        case "already-exists":
+            break; // don't overwrite — re-run init after changing integrationBranch if it needs updating
+    }
+    const scriptsResult = wirePackageJsonScripts(root);
+    switch (scriptsResult.result) {
+        case "added":
+            console.log(`localmerge init: added "${scriptsResult.added.join('", "')}" to package.json scripts.`);
+            writtenFiles.push("package.json");
+            break;
+        case "already-wired":
+            console.log("localmerge init: package.json already has all five scripts — leaving them alone.");
+            break;
+        case "no-package-json":
+            console.log("localmerge init: no package.json found — scripts NOT wired automatically.");
+            console.log('  Add "land"/"sync"/"promote"/"preview"/"preview:restore" -> "localmerge <name>", plus');
+            console.log(`  "preland"/"presync" -> "node ${PREFLIGHT_FILENAME} land"/"sync" yourself.`);
+            break;
+        case "unparseable":
+            console.log("localmerge init: package.json exists but isn't valid JSON — left untouched. Wire the scripts manually.");
+            break;
+    }
+    console.log("");
+    console.log("Next steps:");
+    if (writtenFiles.length > 0) {
+        console.log(`  1. Commit what it wrote — ${writtenFiles.join(", ")}.`);
+        console.log("  2. claude --worktree <name> — the agent takes it from there.");
+    }
+    else {
+        console.log("  1. claude --worktree <name> — the agent takes it from there.");
+        console.log("     (everything was already wired — nothing new to commit)");
+    }
+}
+async function main() {
+    switch (command) {
+        case "init":
+            return init();
+        case "hook": {
+            const sub = rest[0];
+            if (sub === "worktree-create")
+                return runWorktreeCreateHook();
+            console.error(`localmerge hook: unknown hook "${sub ?? ""}". Only "worktree-create" is supported.`);
+            process.exit(1);
+            return;
+        }
+        case "port": {
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                console.error("localmerge port: no localmerge.config found — not a lane.");
+                process.exit(1);
+            }
+            const cfg = await loadConfig(root);
+            const port = lanePort(process.cwd(), cfg);
+            if (port === null) {
+                console.error("localmerge port: current directory doesn't look like a lane worktree.");
+                process.exit(1);
+            }
+            console.log(port);
+            return;
+        }
+        case "land":
+            return land();
+        case "sync":
+            process.exit(await sync());
+            return;
+        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("localmerge prune: no localmerge.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("localmerge prune: nothing to clean up — no already-landed sibling lanes found.");
+            }
+            else {
+                const names = pruned.map((p) => p.split("/").pop()).join(", ");
+                console.log(`localmerge prune: removed ${pruned.length} already-landed lane${pruned.length === 1 ? "" : "s"}: ${names}`);
+            }
+            return;
+        }
+        case "preview":
+            return runPreview(rest);
+        case "build-lock": {
+            const parts = rest[0] === "--" ? rest.slice(1) : rest;
+            return buildLock(parts);
+        }
+        case "check-push": {
+            const root = findRepoRoot();
+            if (!root || !hasConfig(root)) {
+                // No config means LocalMerge isn't enabled for this repo — nothing to enforce.
+                process.exit(0);
+            }
+            const cfg = await loadConfig(root);
+            const stdin = await readStdin();
+            const refUpdates = parseRefUpdates(stdin);
+            // git still invokes pre-push (with empty stdin) for a push that
+            // updates zero refs — e.g. re-pushing a branch that's already exactly
+            // up to date on the remote. There's nothing to block (nothing is
+            // actually changing on the remote either way) and nothing meaningful
+            // for checkCommand to verify — running it anyway just produces a
+            // confusing, unrelated failure (a missing devDependency, say) that
+            // looks exactly like a real block but isn't one. Recognize "nothing
+            // to push" explicitly instead of silently falling through both checks.
+            if (refUpdates.length === 0) {
+                console.log("localmerge check-push: nothing being pushed (already up to date) — skipping checks.");
+                process.exit(0);
+            }
+            if (process.env.LOCALMERGE_EMERGENCY_PUSH === "1") {
+                console.log("\n🚨 LOCALMERGE_EMERGENCY_PUSH is set — bypassing the landing queue.\n");
+            }
+            const result = checkPush(refUpdates, cfg, process.env);
+            if (!result.ok) {
+                console.error(result.message);
+                process.exit(1);
+            }
+            process.exit(runCheckCommand(cfg, root));
+            return;
+        }
+        case "--version":
+        case "-v": {
+            const { join, dirname } = await import("node:path");
+            const { fileURLToPath } = await import("node:url");
+            const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            console.log(pkg.version);
+            return;
+        }
+        default:
+            console.log(`localmerge — keep parallel coding agents in their lane.
+
+Usage:
+  localmerge init                  write a starter localmerge.config.mjs
+  localmerge land                  rebase + push this lane onto the integration branch (queued)
+  localmerge sync                  fast-forward the MAIN checkout to its upstream
+  localmerge promote               ship the integration branch to production (human-only — never script this)
+  localmerge preview [--restore]   swap the MAIN checkout to this lane's working tree, or restore it
+  localmerge build-lock -- <cmd>   run <cmd>, serialized across every lane
+  localmerge port                  print this lane's dev-server port
+  localmerge hook worktree-create  (Claude Code WorktreeCreate hook — not for direct use)
+  localmerge check-push            (used by the pre-push hook — not for direct use)
+`);
+            process.exit(command ? 1 : 0);
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/bin/mergequeue.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};