claude-code-merge-queue 0.1.14

package/dist/lib/wire-hooks.d.ts

@@ -0,0 +1,62 @@
+export declare const PREFLIGHT_FILENAME = "claude-code-local-merge-preflight.mjs";
+export type WireResult = "created" | "merged" | "already-wired" | "unparseable" | "no-husky";
+export declare function wireClaudeSettings(root: string): WireResult;
+export declare function wireHuskyPrePush(root: string): WireResult;
+export type HooksPathResult = "set" | "already-set" | "custom-path";
+/**
+ * A `.husky/pre-push` file on disk enforces nothing on its own — git only
+ * runs it if `core.hooksPath` points somewhere that resolves to it, which is
+ * normally set as a side effect of the package manager's install step
+ * (husky's own `prepare` script). On a freshly cloned repo where nobody's
+ * run that install yet — the exact state Quickstart leaves you in right
+ * after `init` — the file is silently inert and a direct push sails through
+ * uncontested. Since Claude Code Local Merge is the one promising "pushes are gated now,"
+ * it sets this itself instead of depending on a step that may not have
+ * happened yet, mirroring exactly what `husky install` itself does.
+ *
+ * Husky v9 changed its own convention mid-flight: v6–v8 point
+ * core.hooksPath directly at `.husky` (hook files run as-is); v9 points it
+ * at `.husky/_`, a generated wrapper directory that then execs the real
+ * `.husky/<hookname>` file. Both are legitimate, already-correct setups —
+ * only treat something OTHER than either as a deliberate custom path worth
+ * warning about. `.husky/_` doesn't exist yet on the fresh-clone/no-install
+ * case this function exists for, so `.husky` remains the right thing to set
+ * when nothing's configured at all; if the project turns out to be v9,
+ * husky's own next real install corrects it to `.husky/_`.
+ */
+export declare function ensureHooksPath(root: string): HooksPathResult;
+/**
+ * When a landing renames the tool `land`/`sync` invoke (lanekeeper ->
+ * claude-code-local-merge happened once already), any lane that hasn't rebased past that
+ * point yet still has package.json scripts calling the OLD name. The shared
+ * node_modules those lanes symlink from has already moved to the new name,
+ * so `npm run land` fails at the shell level — "lanekeeper: command not
+ * found" — before a single line of this tool's own code runs. Nothing
+ * inside `claude-code-local-merge land` can catch that; the binary it would need to run
+ * to catch it is the very thing that's missing.
+ *
+ * That's why this has to be a plain, standalone script committed into the
+ * CONSUMER repo rather than another `claude-code-local-merge` subcommand: it must still
+ * work the next time the tool itself gets renamed, so it can never invoke
+ * `claude-code-local-merge` (or import from the `claude-code-local-merge` package) itself. It only
+ * reads the target script's own command out of package.json, checks whether
+ * that command's binary actually resolves, and — if not — prints the real
+ * cause (a stale branch) instead of a bare, misleading shell error.
+ */
+export declare function preflightScriptContent(integrationBranch: string): string;
+export type PreflightWireResult = "created" | "already-exists";
+/** Additive/idempotent, same contract as the rest of this file — never overwrites a version you've customized. */
+export declare function wirePreflightScript(root: string, integrationBranch: string): PreflightWireResult;
+export type ScriptsWireResult = "added" | "already-wired" | "unparseable" | "no-package-json";
+/**
+ * The last "copy this yourself" step `init` used to leave on the table:
+ * Quickstart told you to hand-add these scripts to package.json instead of
+ * just adding them. Same additive/idempotent contract as the rest of this
+ * file — only ever fills in scripts that don't exist yet, never overwrites
+ * one you've customized (e.g. if `land` already runs something of yours
+ * first), and does nothing if they're all already there.
+ */
+export declare function wirePackageJsonScripts(root: string): {
+    result: ScriptsWireResult;
+    added: string[];
+};

package/dist/lib/wire-hooks.js

@@ -0,0 +1,230 @@
+/**
+ * The rest of `init`'s job: safely wire the WorktreeCreate hook into
+ * `.claude/settings.json` and the pre-push hook into `.husky/pre-push`,
+ * instead of leaving them as "copy this file yourself" — the exact kind of
+ * manual step that undercuts a tool whose whole point is fewer manual steps.
+ *
+ * Both merges are additive and idempotent: creating the file if it's
+ * missing, adding just our entry without touching anything else if the
+ * file already exists, and doing nothing (safely) if our entry's already
+ * there. Neither ever overwrites content that isn't ours.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, chmodSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const HOOK_COMMAND = "npx claude-code-local-merge hook worktree-create";
+const PRE_PUSH_MARKER = "claude-code-local-merge check-push";
+export const PREFLIGHT_FILENAME = "claude-code-local-merge-preflight.mjs";
+const PACKAGE_SCRIPTS = {
+    land: "claude-code-local-merge land",
+    sync: "claude-code-local-merge sync",
+    promote: "claude-code-local-merge promote",
+    preview: "claude-code-local-merge preview",
+    "preview:restore": "claude-code-local-merge preview --restore",
+    // npm auto-runs "preland"/"presync" before "land"/"sync" — no wiring
+    // needed beyond the script name itself. See wirePreflightScript below for
+    // why the check they run has to live in a plain, tool-name-agnostic file
+    // instead of just being another `claude-code-local-merge` subcommand.
+    preland: `node ${PREFLIGHT_FILENAME} land`,
+    presync: `node ${PREFLIGHT_FILENAME} sync`,
+};
+export function wireClaudeSettings(root) {
+    const dir = join(root, ".claude");
+    const path = join(dir, "settings.json");
+    if (!existsSync(path)) {
+        mkdirSync(dir, { recursive: true });
+        const settings = {
+            hooks: { WorktreeCreate: [{ hooks: [{ type: "command", command: HOOK_COMMAND }] }] },
+        };
+        writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+        return "created";
+    }
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return "unparseable"; // leave it alone — don't guess at broken JSON
+    }
+    settings.hooks ??= {};
+    settings.hooks.WorktreeCreate ??= [];
+    const alreadyWired = settings.hooks.WorktreeCreate.some((group) => group.hooks?.some((h) => h.command?.includes(HOOK_COMMAND)));
+    if (alreadyWired)
+        return "already-wired";
+    settings.hooks.WorktreeCreate.push({ hooks: [{ type: "command", command: HOOK_COMMAND }] });
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    return "merged";
+}
+function shippedPrePushTemplate() {
+    // dist/lib/wire-hooks.js -> ../../hooks/pre-push at the package root.
+    const here = dirname(fileURLToPath(import.meta.url));
+    return readFileSync(join(here, "..", "..", "hooks", "pre-push"), "utf8");
+}
+// The template file is written to stand alone (shebang + comments explaining
+// itself to a human reading it fresh). Appending it whole into an *existing*
+// hook file would duplicate the shebang mid-script and leave behind prose
+// like "copy this file to .husky/pre-push" that's nonsensical once it's
+// already there. So strip the shebang and the leading comment block, and
+// append only the functional part — the same source of truth, no second
+// copy to drift out of sync.
+function functionalSnippet(template) {
+    const lines = template.split("\n");
+    let i = 0;
+    if (lines[0]?.startsWith("#!"))
+        i++;
+    for (; i < lines.length; i++) {
+        const trimmed = lines[i]?.trim() ?? "";
+        if (trimmed !== "" && !trimmed.startsWith("#"))
+            break;
+    }
+    return lines.slice(i).join("\n").trimEnd() + "\n";
+}
+export function wireHuskyPrePush(root) {
+    const huskyDir = join(root, ".husky");
+    if (!existsSync(huskyDir))
+        return "no-husky";
+    const path = join(huskyDir, "pre-push");
+    const template = shippedPrePushTemplate();
+    if (!existsSync(path)) {
+        writeFileSync(path, template);
+        chmodSync(path, 0o755);
+        return "created";
+    }
+    const existing = readFileSync(path, "utf8");
+    if (existing.includes(PRE_PUSH_MARKER))
+        return "already-wired";
+    const marker = "# --- Claude Code Local Merge (appended by `claude-code-local-merge init`) — see node_modules/claude-code-local-merge/hooks/pre-push for the full comments ---";
+    appendFileSync(path, `\n${marker}\n${functionalSnippet(template)}`);
+    chmodSync(path, 0o755);
+    return "merged";
+}
+/**
+ * A `.husky/pre-push` file on disk enforces nothing on its own — git only
+ * runs it if `core.hooksPath` points somewhere that resolves to it, which is
+ * normally set as a side effect of the package manager's install step
+ * (husky's own `prepare` script). On a freshly cloned repo where nobody's
+ * run that install yet — the exact state Quickstart leaves you in right
+ * after `init` — the file is silently inert and a direct push sails through
+ * uncontested. Since Claude Code Local Merge is the one promising "pushes are gated now,"
+ * it sets this itself instead of depending on a step that may not have
+ * happened yet, mirroring exactly what `husky install` itself does.
+ *
+ * Husky v9 changed its own convention mid-flight: v6–v8 point
+ * core.hooksPath directly at `.husky` (hook files run as-is); v9 points it
+ * at `.husky/_`, a generated wrapper directory that then execs the real
+ * `.husky/<hookname>` file. Both are legitimate, already-correct setups —
+ * only treat something OTHER than either as a deliberate custom path worth
+ * warning about. `.husky/_` doesn't exist yet on the fresh-clone/no-install
+ * case this function exists for, so `.husky` remains the right thing to set
+ * when nothing's configured at all; if the project turns out to be v9,
+ * husky's own next real install corrects it to `.husky/_`.
+ */
+export function ensureHooksPath(root) {
+    let current;
+    try {
+        current = execFileSync("git", ["config", "core.hooksPath"], { cwd: root, encoding: "utf8" }).trim();
+    }
+    catch {
+        current = null; // unset
+    }
+    if (current === ".husky" || current === ".husky/_")
+        return "already-set";
+    if (current)
+        return "custom-path"; // respect an existing deliberate setup — don't override it
+    execFileSync("git", ["config", "core.hooksPath", ".husky"], { cwd: root });
+    return "set";
+}
+/**
+ * When a landing renames the tool `land`/`sync` invoke (lanekeeper ->
+ * claude-code-local-merge happened once already), any lane that hasn't rebased past that
+ * point yet still has package.json scripts calling the OLD name. The shared
+ * node_modules those lanes symlink from has already moved to the new name,
+ * so `npm run land` fails at the shell level — "lanekeeper: command not
+ * found" — before a single line of this tool's own code runs. Nothing
+ * inside `claude-code-local-merge land` can catch that; the binary it would need to run
+ * to catch it is the very thing that's missing.
+ *
+ * That's why this has to be a plain, standalone script committed into the
+ * CONSUMER repo rather than another `claude-code-local-merge` subcommand: it must still
+ * work the next time the tool itself gets renamed, so it can never invoke
+ * `claude-code-local-merge` (or import from the `claude-code-local-merge` package) itself. It only
+ * reads the target script's own command out of package.json, checks whether
+ * that command's binary actually resolves, and — if not — prints the real
+ * cause (a stale branch) instead of a bare, misleading shell error.
+ */
+export function preflightScriptContent(integrationBranch) {
+    return `#!/usr/bin/env node
+// Generated by \`claude-code-local-merge init\` (wirePreflightScript) — do not hand-edit;
+// re-run \`claude-code-local-merge init\` after changing integrationBranch instead.
+//
+// Runs as "preland"/"presync" (npm's automatic pre<script> hook) before
+// "land"/"sync". Deliberately self-contained — no import of claude-code-local-merge
+// itself — so it still catches a stale branch even across a future rename
+// of this very tool. See wirePreflightScript in claude-code-local-merge's source for why.
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const target = process.argv[2]; // "land" or "sync"
+const INTEGRATION_BRANCH = ${JSON.stringify(integrationBranch)};
+
+let pkg;
+try {
+  pkg = JSON.parse(readFileSync("package.json", "utf8"));
+} catch {
+  process.exit(0); // can't read it — not this script's problem to raise
+}
+
+const command = pkg.scripts?.[target];
+if (!command) process.exit(0);
+
+const bin = command.trim().split(/\\s+/)[0];
+try {
+  execFileSync("sh", ["-c", \`command -v -- "\${bin}"\`], { stdio: "ignore" });
+} catch {
+  console.error(\`\\n✋ '\${bin}' isn't resolvable — this branch's package.json looks stale relative to origin/\${INTEGRATION_BRANCH} (the tool it invokes may have been renamed or removed there since this branch was last rebased).\`);
+  console.error(\`   Fix: git fetch origin \${INTEGRATION_BRANCH} && git rebase origin/\${INTEGRATION_BRANCH}, then retry.\\n\`);
+  process.exit(1);
+}
+`;
+}
+/** Additive/idempotent, same contract as the rest of this file — never overwrites a version you've customized. */
+export function wirePreflightScript(root, integrationBranch) {
+    const path = join(root, PREFLIGHT_FILENAME);
+    if (existsSync(path))
+        return "already-exists";
+    writeFileSync(path, preflightScriptContent(integrationBranch));
+    return "created";
+}
+/**
+ * The last "copy this yourself" step `init` used to leave on the table:
+ * Quickstart told you to hand-add these scripts to package.json instead of
+ * just adding them. Same additive/idempotent contract as the rest of this
+ * file — only ever fills in scripts that don't exist yet, never overwrites
+ * one you've customized (e.g. if `land` already runs something of yours
+ * first), and does nothing if they're all already there.
+ */
+export function wirePackageJsonScripts(root) {
+    const path = join(root, "package.json");
+    if (!existsSync(path))
+        return { result: "no-package-json", added: [] };
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return { result: "unparseable", added: [] };
+    }
+    pkg.scripts ??= {};
+    const added = [];
+    for (const [name, command] of Object.entries(PACKAGE_SCRIPTS)) {
+        if (!(name in pkg.scripts)) {
+            pkg.scripts[name] = command;
+            added.push(name);
+        }
+    }
+    if (added.length === 0)
+        return { result: "already-wired", added: [] };
+    writeFileSync(path, JSON.stringify(pkg, null, 2) + "\n");
+    return { result: "added", added };
+}

package/dist/preview.d.ts

@@ -0,0 +1 @@
+export declare function runPreview(args: string[]): Promise<void>;

package/dist/preview.js

@@ -0,0 +1,119 @@
+/**
+ * preview.ts — instantly preview a lane's working tree on the ONE shared dev
+ * server, no build, no deploy.
+ *
+ * A hosted preview deployment is too slow for "let me glance at this." A dev
+ * server is just files on disk being watched by your framework's bundler —
+ * so this copies a lane's working tree (including uncommitted changes,
+ * exactly what's being iterated on) straight onto the MAIN checkout. The
+ * bundler picks up the change and hot-reloads in seconds.
+ *
+ * This is framework-agnostic by construction: it's an rsync, not a build
+ * step, so it has no opinion about Next.js, Vite, or anything else — your
+ * own dev server does the actual watching and reloading. The one place a
+ * framework's fingerprints show up is `buildOutputDirs` in your config
+ * (never copy someone's stale ".next" or "dist" over a live checkout).
+ *
+ *   claude-code-local-merge preview            from a lane worktree — swap the dev server
+ *                                 to show THIS lane's current working tree.
+ *   claude-code-local-merge preview --restore  from anywhere — put the dev server back on
+ *                                 the integration branch's real HEAD.
+ *
+ * Safety:
+ *   - Refuses to start a new preview if the MAIN checkout isn't clean (a
+ *     previous preview wasn't restored, or it has real local changes) —
+ *     never silently overwrites unknown state.
+ *   - Additive only (no rsync --delete): a file the lane DELETED won't show
+ *     up deleted in the preview. Deleting untracked files in a live checkout
+ *     with no git record to recover them isn't a risk worth taking for a
+ *     "quick look" tool — this only ever adds or modifies files.
+ *   - Exact restore, not a guessed `git clean`: every newly-created
+ *     untracked path introduced by the swap is recorded in a manifest up
+ *     front, and restore removes precisely those paths, then
+ *     `git checkout -- .` to revert every modified TRACKED file to HEAD.
+ *   - Never touches .git, node_modules, build output, or env files in the
+ *     target — only the source tree itself moves.
+ */
+import { execSync, execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveMainCheckout } from "./lib/main-checkout.js";
+import { loadConfig } from "./lib/config.js";
+const DIM = "\x1b[2m", RESET = "\x1b[0m", RED = "\x1b[31m", GREEN = "\x1b[32m";
+// Always excluded, regardless of framework — never rsync git internals,
+// dependencies, or secrets over a live checkout.
+const BASE_EXCLUDES = [".git", "node_modules", ".env", ".env.local"];
+function gitStatus(dir) {
+    return execFileSync("git", ["status", "--porcelain"], { cwd: dir, encoding: "utf8" });
+}
+function restore(target, manifestPath) {
+    if (!existsSync(manifestPath)) {
+        console.log(`${DIM}preview: no active preview to restore.${RESET}`);
+        return;
+    }
+    const { addedPaths } = JSON.parse(readFileSync(manifestPath, "utf8"));
+    console.log(`${DIM}reverting tracked-file changes on the dev checkout…${RESET}`);
+    execFileSync("git", ["checkout", "--", "."], { cwd: target, stdio: "inherit" });
+    for (const p of addedPaths) {
+        rmSync(join(target, p), { recursive: true, force: true });
+    }
+    unlinkSync(manifestPath);
+    const head = execFileSync("git", ["rev-parse", "--short", "HEAD"], { cwd: target, encoding: "utf8" }).trim();
+    console.log(`${GREEN}✓ dev server restored to HEAD @ ${head}.${RESET}`);
+}
+function preview(source, target, manifestPath, excludes) {
+    if (source === target) {
+        console.error("claude-code-local-merge preview: refusing to run from the dev-server checkout itself — run this from a lane worktree.");
+        process.exit(1);
+    }
+    if (existsSync(manifestPath)) {
+        console.error(`${RED}preview: a preview is already active on the dev server.${RESET} Run 'claude-code-local-merge preview --restore' first.`);
+        process.exit(1);
+    }
+    const before = gitStatus(target);
+    if (before.trim() !== "") {
+        console.error(`${RED}preview: the dev-server checkout isn't clean — refusing to swap over unknown local changes.${RESET}`);
+        console.error(before);
+        process.exit(1);
+    }
+    const branch = execFileSync("git", ["-C", source, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).trim();
+    console.log(`${DIM}copying ${branch}'s working tree onto the dev server…${RESET}`);
+    const rsyncArgs = ["-a", ...excludes.flatMap((e) => ["--exclude", e]), `${source}/`, `${target}/`];
+    const rsync = spawnSync("rsync", rsyncArgs, { stdio: "inherit" });
+    if (rsync.status !== 0) {
+        console.error(`${RED}preview: rsync failed.${RESET}`);
+        process.exit(1);
+    }
+    const after = gitStatus(target);
+    const addedPaths = after
+        .split("\n")
+        .filter((l) => l.startsWith("??"))
+        .map((l) => l.slice(3).trim());
+    writeFileSync(manifestPath, JSON.stringify({ branch, addedPaths }, null, 2));
+    console.log(`${GREEN}✓ dev server now showing ${branch}.${RESET} Refresh the browser.`);
+    console.log(`${DIM}Run 'claude-code-local-merge preview --restore' when done.${RESET}`);
+}
+export async function runPreview(args) {
+    const source = process.cwd();
+    const target = resolveMainCheckout(source);
+    const manifestPath = join(tmpdir(), `claude-code-local-merge-preview-manifest-${createHash("sha1").update(target).digest("hex").slice(0, 12)}.json`);
+    // Fail fast and legibly if rsync isn't available, rather than a cryptic
+    // spawn ENOENT partway through copying files.
+    try {
+        execSync("command -v rsync", { stdio: "ignore" });
+    }
+    catch {
+        console.error("claude-code-local-merge preview: rsync is required and wasn't found on PATH.");
+        process.exit(1);
+    }
+    if (args.includes("--restore")) {
+        restore(target, manifestPath);
+    }
+    else {
+        const cfg = await loadConfig(source);
+        const excludes = [...BASE_EXCLUDES, ...cfg.buildOutputDirs];
+        preview(source, target, manifestPath, excludes);
+    }
+}

package/dist/promote.d.ts

@@ -0,0 +1 @@
+export declare function promote(): Promise<number>;

package/dist/promote.js

@@ -0,0 +1,77 @@
+/**
+ * promote.ts — ship the integration branch to production by fast-forwarding
+ * origin/<productionBranch> to origin/<integrationBranch>.
+ *
+ * This is the one command in Claude Code Local Merge that's deliberately NOT part of the
+ * automated workflow. Agents land on `integrationBranch` continuously and
+ * autonomously (see the CLAUDE.md workflow section `claude-code-local-merge init` writes) —
+ * production only moves when a human decides to run this. If your
+ * claude-code-local-merge.config has no `productionBranch` set, there's nothing to
+ * promote: `integrationBranch` already IS production, and this is a no-op.
+ *
+ *   Usage:  claude-code-local-merge promote   (run from anywhere in the repo)
+ *
+ * Safe by construction:
+ *   - Fetches first, then verifies origin/productionBranch is an ANCESTOR of
+ *     origin/integrationBranch — a pure fast-forward, linear history, no
+ *     merge commit. If production has commits not on the integration branch
+ *     (someone pushed it directly), it ABORTS rather than force anything.
+ *   - No local checkout needed: pushes the remote ref straight across.
+ *   - --no-verify on the push: every commit on the integration branch
+ *     already passed the full pre-push check when it landed, so re-running
+ *     that suite here is pure waste. Your own CI still gates whatever runs
+ *     on the production branch on its side.
+ *   - Nothing to promote (already equal) → reports and exits 0.
+ */
+import { execFileSync } from "node:child_process";
+import { hasConfig, loadConfig } from "./lib/config.js";
+function git(args, { allowFail = false } = {}) {
+    try {
+        return { ok: true, out: execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim() };
+    }
+    catch (e) {
+        const err = e;
+        if (!allowFail)
+            throw e;
+        return { ok: false, out: `${err.stdout ?? ""}${err.stderr ?? ""}`.trim() };
+    }
+}
+export async function promote() {
+    if (!hasConfig()) {
+        console.error("claude-code-local-merge promote: no claude-code-local-merge.config found at the repo root.");
+        return 1;
+    }
+    const cfg = await loadConfig();
+    if (!cfg.productionBranch) {
+        console.log(`claude-code-local-merge promote: no productionBranch configured — '${cfg.integrationBranch}' already IS production. Nothing to do.`);
+        return 0;
+    }
+    const { integrationBranch, productionBranch } = cfg;
+    git(["fetch", "origin", "--quiet"], { allowFail: true });
+    const prod = git(["rev-parse", `origin/${productionBranch}`], { allowFail: true });
+    const integ = git(["rev-parse", `origin/${integrationBranch}`], { allowFail: true });
+    if (!prod.ok || !integ.ok) {
+        console.error(`claude-code-local-merge promote: could not resolve origin/${productionBranch} or origin/${integrationBranch} — are both branches created and fetched?`);
+        return 1;
+    }
+    if (prod.out === integ.out) {
+        console.log(`claude-code-local-merge promote: ${productionBranch} already at ${integrationBranch} (${integ.out.slice(0, 7)}) — nothing to ship.`);
+        return 0;
+    }
+    // Pure fast-forward only: origin/productionBranch must be an ancestor of
+    // origin/integrationBranch.
+    const ff = git(["merge-base", "--is-ancestor", `origin/${productionBranch}`, `origin/${integrationBranch}`], { allowFail: true });
+    if (!ff.ok) {
+        console.error(`claude-code-local-merge promote: origin/${productionBranch} has commits NOT on origin/${integrationBranch} — history has diverged.\n` +
+            `Someone pushed ${productionBranch} directly. Reconcile manually before promoting.\n` +
+            "Left untouched — refusing to force-push production.");
+        return 1;
+    }
+    const push = git(["push", "--no-verify", "origin", `origin/${integrationBranch}:${productionBranch}`], { allowFail: true });
+    if (!push.ok) {
+        console.error(`claude-code-local-merge promote: push to ${productionBranch} FAILED — production NOT updated.\n${push.out}`);
+        return 1;
+    }
+    console.log(`claude-code-local-merge promote: shipped ${integrationBranch} → ${productionBranch}  ${prod.out.slice(0, 7)} → ${integ.out.slice(0, 7)}`);
+    return 0;
+}

package/dist/sync.d.ts

@@ -0,0 +1,16 @@
+import { type ClaudeCodeLocalMergeConfig } 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 claude-code-local-merge.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
+ * `claude-code-local-merge sync` (no caller-provided config) still loads fresh from
+ * MAIN, same as before.
+ */
+export declare function sync(providedCfg?: ClaudeCodeLocalMergeConfig): Promise<number>;