borgmcp 1.0.6 → 1.0.7

package/dist/terminal-title.js

@@ -1,68 +1 @@
-/**
- * Terminal-title setter for borg drone sessions.
- *
- * Multiple Claude Code sessions across sibling worktrees are visually
- * indistinguishable in Cmd-Tab / tab bars / Mission Control on macOS,
- * and likewise on most Linux terminal emulators. Setting the terminal
- * title via the OSC 0 / OSC 2 escape gives each window a free per-
- * session identity.
- *
- * Format (Queen-specified):
- *   - Assimilated drone session: `borg · <label> · <cubeName>`
- *   - Unassimilated session:     `borg · <repo-basename>`
- *
- * Why OSC 0 (`\x1b]0;…\x07`): sets both window title AND icon name on
- * most terminals. OSC 2 sets only window title; OSC 1 sets only icon
- * name. OSC 0 is the maximally-portable choice — works in iTerm2,
- * macOS Terminal, kitty, alacritty, ghostty, GNOME Terminal, xterm.
- *
- * Lifetime: the escape is emitted once, before spawning Claude Code.
- * Claude Code itself does not set its own window title (verified
- * 2026-05-11), so the borg-set title persists for the whole session.
- *
- * Limitations (acceptable for v1; flagged for future):
- *   - Title doesn't update mid-session on `borg:assimilate`. The
- *     borgmcp client process can't write the escape post-spawn
- *     because stdio is owned by Claude Code at that point (and stdio
- *     to Claude is JSON-RPC — terminal escapes would be parsed as
- *     invalid messages).
- *   - Falls back to repo-basename for the unassimilated case; loses
- *     drone identity until the cube is joined. Typical pattern is
- *     "drone has been around long enough that cubes.json is already
- *     populated," so the assimilated path is the common case.
- */
-/**
- * Pure: compose the title string for a session. Exported so tests can
- * exercise every branch without TTY / process / fs dependencies.
- *
- * @param activeDrone — `{label, cubeName}` if this project is
- *   assimilated to a cube, null otherwise.
- * @param repoBasename — fallback identity for the unassimilated case
- *   (typically `basename(process.cwd())`).
- */
-export function composeTerminalTitle(activeDrone, repoBasename) {
-    if (activeDrone) {
-        return `borg · ${activeDrone.label} · ${activeDrone.cubeName}`;
-    }
-    return `borg · ${repoBasename}`;
-}
-/**
- * Side-effecting: emit the OSC 0 escape to stdout, but only if stdout
- * is a TTY. When stdout is piped (CI, redirection, scripted
- * invocation), emitting the raw escape would pollute the captured
- * output without doing anything useful — so we no-op.
- *
- * Returns the title string that WOULD have been emitted, regardless of
- * TTY state, so callers can log it independently for diagnostics.
- */
-export function setTerminalTitle(activeDrone, repoBasename, stdout = process.stdout) {
-    const title = composeTerminalTitle(activeDrone, repoBasename);
-    if (stdout.isTTY) {
-        // OSC 0: ESC ] 0 ; <title> BEL
-        // (BEL terminator is honored by all OSC-supporting terminals;
-        // ST = `ESC \` is an alternative but BEL has wider compat.)
-        stdout.write(`\x1b]0;${title}\x07`);
-    }
-    return title;
-}
-//# sourceMappingURL=terminal-title.js.map
+function n(e,r){return e?`borg \xB7 ${e.label} \xB7 ${e.cubeName}`:`borg \xB7 ${r}`}function o(e,r,t=process.stdout){const i=n(e,r);return t.isTTY&&t.write(`\x1B]0;${i}\x07`),i}export{n as composeTerminalTitle,o as setTerminalTitle};

package/dist/token-crypto.js

@@ -1,91 +1 @@
-/**
- * gh#557 — AES-256-GCM crypto for the keychain-less token store.
- *
- * ⚠ OBFUSCATION-GRADE, BY DESIGN. The encryption key is DERIVED from stable
- * machine+user identifiers (hostname, username, platform) — there is no
- * passphrase. This means:
- *
- *   - It DEFENDS against casual/accidental exposure: a dotfile backup, an
- *     `scp -r ~`, a synced home directory, a shoulder-surfed `cat`. The
- *     on-disk bytes are ciphertext, not a readable token.
- *   - It does NOT defend against a same-uid process or root on the SAME
- *     machine: anything that can read ~/.borg/credentials can also read the
- *     same hostname/username/platform and re-derive the key. That is an
- *     accepted limitation (SR-endorsed, gh#557 ESCALATION 2) and matches
- *     gcloud's own at-rest posture for its credential files.
- *
- * The OS keychain (config.ts default) remains the real at-rest encryption
- * path; this fallback only engages when no keychain is available (headless
- * Linux without Secret Service, etc.).
- *
- * Machine identifiers are injected (MachineKeyInputs) rather than read here,
- * both for testability and so the production caller can choose OS primitives
- * that work in headless/container environments (os.hostname()/os.userInfo()
- * never spawn a subprocess, unlike a hardware machine-id probe).
- */
-import crypto from 'crypto';
-/**
- * Static application salt — domain-separates this key derivation from any
- * other use of the same machine identifiers. NOT a secret (it ships in the
- * published client); its only job is to make the derived key specific to
- * borg-mcp token storage.
- */
-const KEY_SALT = 'borg-mcp/token-store/v1';
-const ENVELOPE_VERSION = 'v1';
-const IV_BYTES = 12; // 96-bit nonce, the GCM standard
-const KEY_BYTES = 32; // AES-256
-/**
- * Derive a stable 32-byte AES-256 key from machine+user identifiers.
- * Deterministic for a given machine+user (so a token written today decrypts
- * tomorrow) and distinct across machines/users.
- */
-export function deriveMachineKey(inputs) {
-    const material = [inputs.hostname, inputs.username, inputs.platform, KEY_SALT].join('\0');
-    return crypto.createHash('sha256').update(material).digest(); // 32 bytes
-}
-/**
- * Encrypt a plaintext string under the given key. Returns a versioned,
- * dot-delimited envelope: `v1.<base64(iv)>.<base64(tag)>.<base64(ct)>`.
- * A fresh random IV per call means the same plaintext encrypts differently
- * every time (no deterministic-ciphertext leak).
- */
-export function encryptString(plaintext, key) {
-    if (key.length !== KEY_BYTES) {
-        throw new Error(`token-crypto: key must be ${KEY_BYTES} bytes`);
-    }
-    const iv = crypto.randomBytes(IV_BYTES);
-    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-    const ciphertext = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return [
-        ENVELOPE_VERSION,
-        iv.toString('base64'),
-        tag.toString('base64'),
-        ciphertext.toString('base64'),
-    ].join('.');
-}
-/**
- * Decrypt an envelope produced by encryptString. Throws on a malformed
- * envelope, a wrong key, or a tampered ciphertext (the GCM auth tag fails
- * verification) — fail-closed is correct for credential material.
- */
-export function decryptString(envelope, key) {
-    if (key.length !== KEY_BYTES) {
-        throw new Error(`token-crypto: key must be ${KEY_BYTES} bytes`);
-    }
-    const parts = envelope.split('.');
-    if (parts.length !== 4 || parts[0] !== ENVELOPE_VERSION) {
-        throw new Error('token-crypto: malformed or unsupported envelope');
-    }
-    const iv = Buffer.from(parts[1], 'base64');
-    const tag = Buffer.from(parts[2], 'base64');
-    const ciphertext = Buffer.from(parts[3], 'base64');
-    if (iv.length !== IV_BYTES) {
-        throw new Error('token-crypto: malformed IV');
-    }
-    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
-    decipher.setAuthTag(tag);
-    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-    return plaintext.toString('utf8');
-}
-//# sourceMappingURL=token-crypto.js.map
+import n from"crypto";const u="borg-mcp/token-store/v1",f="v1",p=12,c=32;function m(e){const r=[e.hostname,e.username,e.platform,u].join("\0");return n.createHash("sha256").update(r).digest()}function l(e,r){if(r.length!==c)throw new Error(`token-crypto: key must be ${c} bytes`);const t=n.randomBytes(p),o=n.createCipheriv("aes-256-gcm",r,t),a=Buffer.concat([o.update(e,"utf8"),o.final()]),s=o.getAuthTag();return[f,t.toString("base64"),s.toString("base64"),a.toString("base64")].join(".")}function E(e,r){if(r.length!==c)throw new Error(`token-crypto: key must be ${c} bytes`);const t=e.split(".");if(t.length!==4||t[0]!==f)throw new Error("token-crypto: malformed or unsupported envelope");const o=Buffer.from(t[1],"base64"),a=Buffer.from(t[2],"base64"),s=Buffer.from(t[3],"base64");if(o.length!==p)throw new Error("token-crypto: malformed IV");const i=n.createDecipheriv("aes-256-gcm",r,o);return i.setAuthTag(a),Buffer.concat([i.update(s),i.final()]).toString("utf8")}export{E as decryptString,m as deriveMachineKey,l as encryptString};

package/dist/token-store.js

@@ -1,222 +1 @@
-/**
- * gh#557 — token storage backends + selection.
- *
- * config.ts exposes the public token API (storeIdToken/getIdToken/...). This
- * module supplies the interchangeable storage engines it sits on top of:
- *
- *   - KeychainBackend      — OS keychain via @napi-rs/keyring (the default;
- *                            real platform at-rest encryption).
- *   - EncryptedFileBackend — ~/.borg/credentials, all accounts in one
- *                            AES-256-GCM blob, file 0600 / dir 0700. Engages
- *                            only when no keychain is available. Obfuscation-
- *                            grade (see token-crypto.ts).
- *   - caller-managed       — BORG_TOKEN / BORG_TOKEN_FILE: an externally
- *                            supplied id_token, used read-only with no store
- *                            (the caller owns its lifecycle/freshness).
- *
- * Every engine takes its side-effecting dependencies (keyring entry factory,
- * fs, machine key) by injection so the logic is unit-tested without a real
- * keychain or disk.
- */
-import path from 'path';
-import crypto from 'crypto';
-import { AsyncEntry } from '@napi-rs/keyring';
-import { decryptString, encryptString } from './token-crypto.js';
-const SERVICE_NAME = 'borg-mcp';
-const defaultEntryFactory = (account) => new AsyncEntry(SERVICE_NAME, account);
-/**
- * Build the OS-keychain backend. Preserves config.ts's prior semantics:
- * a missing entry reads as null, and delete is silent on a NoEntry error
- * (idempotent clear) while other errors propagate (fail-loud).
- */
-export function makeKeychainBackend(entryFactory = defaultEntryFactory) {
-    return {
-        name: 'keychain',
-        async get(account) {
-            return (await entryFactory(account).getPassword()) ?? null;
-        },
-        async set(account, value) {
-            await entryFactory(account).setPassword(value);
-        },
-        async delete(account) {
-            try {
-                await entryFactory(account).deletePassword();
-            }
-            catch (err) {
-                const msg = String(err?.message ?? '');
-                if (/no entry|not found|no matching/i.test(msg))
-                    return;
-                throw err;
-            }
-        },
-    };
-}
-// gh#570 lock tuning. Token writes are tiny + infrequent, so a short retry
-// cadence + a generous staleness window are right: the staleness window only
-// has to exceed a real write (milliseconds), and a crashed lock-holder is
-// reclaimed after it.
-const LOCK_RETRY_DELAY_MS = 25;
-const LOCK_MAX_WAIT_MS = 2000;
-const LOCK_STALE_MS = 10_000;
-function defaultSleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function defaultUniqueSuffix() {
-    // PID + random keeps two concurrent writers' temp files distinct so the
-    // temp write itself never races. crypto is already a client dependency.
-    return `${process.pid}.${crypto.randomBytes(6).toString('hex')}`;
-}
-/**
- * Build the encrypted-file backend. All accounts live in one JSON object
- * encrypted as a single AES-256-GCM envelope at `filePath`.
- *
- * A missing file reads as an empty map. A file that won't decrypt (wrong
- * machine key after a hostname change, truncation, tampering) is ALSO
- * treated as empty: the only consequence is the user re-runs `borg setup`,
- * which is the right fail-safe for credential material — a hard crash on a
- * corrupt dotfile would be worse UX than transparent re-auth.
- *
- * gh#570 — concurrency + atomicity. Multiple `borg` processes (e.g. sibling
- * drone sessions on one host) can share `~/.borg/credentials`. Two fixes:
- *  - Anti-lost-update (load-bearing): `set`/`delete` serialize their whole
- *    read-modify-write cycle behind an O_EXCL lock file, so concurrent
- *    writers no longer each read a stale map and clobber each other.
- *  - Anti-corruption: every write goes to a unique temp file then `rename`s
- *    into place, so a reader (which is intentionally lock-FREE) always sees a
- *    complete old-or-new file, never a torn one.
- */
-export function makeEncryptedFileBackend(deps) {
-    const { filePath, key, fs } = deps;
-    const sleep = deps.sleep ?? defaultSleep;
-    const now = deps.now ?? Date.now;
-    const uniqueSuffix = deps.uniqueSuffix ?? defaultUniqueSuffix;
-    const lockPath = `${filePath}.lock`;
-    async function readMap() {
-        let raw;
-        try {
-            raw = await fs.readFile(filePath);
-        }
-        catch {
-            return {}; // missing file → no stored tokens yet
-        }
-        try {
-            const json = decryptString(raw.trim(), key);
-            const parsed = JSON.parse(json);
-            return parsed && typeof parsed === 'object' ? parsed : {};
-        }
-        catch {
-            return {}; // undecryptable / corrupt → fail safe to re-auth
-        }
-    }
-    async function writeMap(map) {
-        await fs.mkdir(path.dirname(filePath), 0o700);
-        // Atomic write: encrypt → temp → rename. rename preserves the temp's 0600.
-        const tmpPath = `${filePath}.${uniqueSuffix()}.tmp`;
-        await fs.writeFile(tmpPath, encryptString(JSON.stringify(map), key), 0o600);
-        try {
-            await fs.rename(tmpPath, filePath);
-        }
-        catch (err) {
-            // rename failed (disk full / permission). Remove the orphaned temp so
-            // repeated failures don't accumulate .tmp files, then rethrow so the
-            // caller still fails loud. Cleanup is best-effort — a failed unlink must
-            // not mask the original error.
-            try {
-                await fs.removeFile(tmpPath);
-            }
-            catch {
-                /* ignore cleanup failure — the original rename error takes precedence */
-            }
-            throw err;
-        }
-    }
-    /**
-     * Run `fn` while holding the O_EXCL lock, serializing read-modify-write
-     * across processes. A lock left by a crashed holder is reclaimed once it is
-     * older than LOCK_STALE_MS. If the lock can't be acquired within
-     * LOCK_MAX_WAIT_MS, proceed best-effort (steal it): the worst case is the
-     * original benign lost-update, never a stuck auth.
-     */
-    async function withFileLock(fn) {
-        const deadline = now() + LOCK_MAX_WAIT_MS;
-        let held = false;
-        while (!held) {
-            held = await fs.createExclusive(lockPath, `${process.pid}@${now()}`);
-            if (held)
-                break;
-            const age = await fs.fileAgeMs(lockPath);
-            if (age !== null && age > LOCK_STALE_MS) {
-                await fs.removeFile(lockPath); // reclaim a stale (crashed-holder) lock
-                continue;
-            }
-            if (now() >= deadline) {
-                await fs.removeFile(lockPath); // last resort: steal + proceed best-effort
-                held = await fs.createExclusive(lockPath, `${process.pid}@${now()}`);
-                break;
-            }
-            await sleep(LOCK_RETRY_DELAY_MS);
-        }
-        try {
-            return await fn();
-        }
-        finally {
-            if (held)
-                await fs.removeFile(lockPath);
-        }
-    }
-    return {
-        name: 'encrypted-file',
-        async get(account) {
-            // Lock-free: temp+rename guarantees readMap sees a complete file.
-            const map = await readMap();
-            return Object.prototype.hasOwnProperty.call(map, account) ? map[account] : null;
-        },
-        set(account, value) {
-            return withFileLock(async () => {
-                const map = await readMap();
-                map[account] = value;
-                await writeMap(map);
-            });
-        },
-        delete(account) {
-            return withFileLock(async () => {
-                const map = await readMap();
-                if (Object.prototype.hasOwnProperty.call(map, account)) {
-                    delete map[account];
-                    await writeMap(map);
-                }
-            });
-        },
-    };
-}
-/**
- * Select the persistent backend: a forced choice (BORG_TOKEN_STORE=keychain|file)
- * wins and skips the probe; otherwise probe the keychain and fall back to the
- * encrypted file when it's unavailable.
- */
-export async function selectTokenBackend(deps) {
-    if (deps.forced === 'keychain')
-        return deps.makeKeychain();
-    if (deps.forced === 'file')
-        return deps.makeFile();
-    return (await deps.keyringAvailable()) ? deps.makeKeychain() : deps.makeFile();
-}
-/**
- * Resolve an externally-supplied id_token (no storage). BORG_TOKEN takes
- * precedence; otherwise BORG_TOKEN_FILE is read from disk. Returns null when
- * neither is configured. The value is trimmed (env vars and files commonly
- * carry trailing newlines). The caller owns this token's freshness, so it
- * bypasses the keychain AND the expiry check in config.ts.
- */
-export async function readCallerManagedIdToken(deps) {
-    const inline = deps.env.BORG_TOKEN?.trim();
-    if (inline)
-        return inline;
-    const file = deps.env.BORG_TOKEN_FILE?.trim();
-    if (file) {
-        const contents = await deps.readFile(file);
-        return contents.trim();
-    }
-    return null;
-}
-//# sourceMappingURL=token-store.js.map
+import p from"path";import d from"crypto";import{AsyncEntry as h}from"@napi-rs/keyring";import{decryptString as k,encryptString as g}from"./token-crypto.js";const S="borg-mcp",E=t=>new h(S,t);function K(t=E){return{name:"keychain",async get(e){return await t(e).getPassword()??null},async set(e,o){await t(e).setPassword(o)},async delete(e){try{await t(e).deletePassword()}catch(o){const a=String(o?.message??"");if(/no entry|not found|no matching/i.test(a))return;throw o}}}}const O=25,_=2e3,F=1e4;function x(t){return new Promise(e=>setTimeout(e,t))}function v(){return`${process.pid}.${d.randomBytes(6).toString("hex")}`}function T(t){const{filePath:e,key:o,fs:a}=t,m=t.sleep??x,s=t.now??Date.now,y=t.uniqueSuffix??v,c=`${e}.lock`;async function l(){let r;try{r=await a.readFile(e)}catch{return{}}try{const n=k(r.trim(),o),i=JSON.parse(n);return i&&typeof i=="object"?i:{}}catch{return{}}}async function u(r){await a.mkdir(p.dirname(e),448);const n=`${e}.${y()}.tmp`;await a.writeFile(n,g(JSON.stringify(r),o),384);try{await a.rename(n,e)}catch(i){try{await a.removeFile(n)}catch{}throw i}}async function f(r){const n=s()+_;let i=!1;for(;!i&&(i=await a.createExclusive(c,`${process.pid}@${s()}`),!i);){const w=await a.fileAgeMs(c);if(w!==null&&w>F){await a.removeFile(c);continue}if(s()>=n){await a.removeFile(c),i=await a.createExclusive(c,`${process.pid}@${s()}`);break}await m(O)}try{return await r()}finally{i&&await a.removeFile(c)}}return{name:"encrypted-file",async get(r){const n=await l();return Object.prototype.hasOwnProperty.call(n,r)?n[r]:null},set(r,n){return f(async()=>{const i=await l();i[r]=n,await u(i)})},delete(r){return f(async()=>{const n=await l();Object.prototype.hasOwnProperty.call(n,r)&&(delete n[r],await u(n))})}}}async function b(t){return t.forced==="keychain"?t.makeKeychain():t.forced==="file"?t.makeFile():await t.keyringAvailable()?t.makeKeychain():t.makeFile()}async function L(t){const e=t.env.BORG_TOKEN?.trim();if(e)return e;const o=t.env.BORG_TOKEN_FILE?.trim();return o?(await t.readFile(o)).trim():null}export{T as makeEncryptedFileBackend,K as makeKeychainBackend,L as readCallerManagedIdToken,b as selectTokenBackend};

package/dist/types.js

@@ -1,5 +0,0 @@
-/**
- * Type definitions for Borg MCP Client
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/version.js

@@ -1,78 +1,2 @@
-/**
- * Runtime version reader.
- *
- * Single source of truth for the borgmcp client version — read at runtime
- * from `package.json` relative to `import.meta.url`, NOT hardcoded.
- *
- * Consumers:
- *   - `index.ts` — passed into the MCP `Server({ name, version })`
- *     constructor so Claude Code's `/mcp` view shows the real version
- *     instead of the long-standing hardcoded "0.1.0".
- *   - `claude.ts` / `setup.ts` / `regen.ts` / `log-audit.ts` — each
- *     binary supports a `--version` flag that prints `borgmcp X.Y.Z`
- *     and exits 0 before any side-effecting work begins.
- *
- * Implementation notes:
- *   - Uses `readFileSync` on the resolved path relative to this module's
- *     `import.meta.url`. The compiled `dist/version.js` sits one level
- *     above `package.json` at the package root, so `../package.json` is
- *     the relative resolution. This works under both `node dist/...`
- *     and `npm run start`; the path resolution is independent of CWD.
- *   - Result is cached at module-eval time. The package.json is part of
- *     the published tarball and immutable for any given install.
- *   - Falls back to `'unknown'` if the read fails (corrupted install,
- *     someone deleted package.json, etc.) — never throws, so a fresh
- *     `--version` invocation can't kill a CLI launch.
- */
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-function readPackageVersion() {
-    try {
-        const here = fileURLToPath(import.meta.url);
-        const pkgPath = join(dirname(here), '..', 'package.json');
-        const raw = readFileSync(pkgPath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.version === 'string' && parsed.version.length > 0) {
-            return parsed.version;
-        }
-        return 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-const VERSION = readPackageVersion();
-/**
- * Return the installed borgmcp version (the same string as
- * `client/package.json`'s `version` field). Cached at module load.
- */
-export function getPackageVersion() {
-    return VERSION;
-}
-/**
- * Standard `--version` handler — call near the top of any CLI entry
- * point. If `process.argv` contains `--version` or `-v`, prints
- * `borgmcp X.Y.Z` to stdout and exits 0. Otherwise returns silently
- * so the caller can continue with normal CLI work.
- *
- * Examples:
- *   - `borg --version`    → "borgmcp 0.6.0"
- *   - `borg-mcp -v`       → "borgmcp 0.6.0"
- *   - `borg assimilate`   → continues to assimilation flow
- *   - `borg-setup`        → continues to interactive OAuth wizard
- */
-/**
- * gh#285: read the on-disk package.json version fresh (not cached).
- * Used by the regen handler to detect post-upgrade version mismatch.
- */
-export function getOnDiskVersion() {
-    return readPackageVersion();
-}
-export function handleVersionFlag() {
-    if (process.argv.includes('--version') || process.argv.includes('-v')) {
-        process.stdout.write(`borgmcp ${VERSION}\n`);
-        process.exit(0);
-    }
-}
-//# sourceMappingURL=version.js.map
+import{readFileSync as i}from"node:fs";import{fileURLToPath as c}from"node:url";import{dirname as a,join as p}from"node:path";function n(){try{const o=c(import.meta.url),t=p(a(o),"..","package.json"),s=i(t,"utf-8"),r=JSON.parse(s);return typeof r.version=="string"&&r.version.length>0?r.version:"unknown"}catch{return"unknown"}}const e=n();function m(){return e}function d(){return n()}function l(){(process.argv.includes("--version")||process.argv.includes("-v"))&&(process.stdout.write(`borgmcp ${e}
+`),process.exit(0))}export{d as getOnDiskVersion,m as getPackageVersion,l as handleVersionFlag};

package/dist/worktree-lifecycle.js

@@ -1,173 +1,2 @@
-/**
- * gh#33 — worktree lifecycle as product behavior.
- *
- * Pure git-decision helpers behind an injected `runSync` seam (matching
- * the `AssimilateDeps.runSync` shape), so every branch is unit-testable
- * without a live repo. This module DECIDES + emits git command sequences;
- * it never launches agents and never touches the cube API.
- *
- * Design spec: docs/superpowers/specs/2026-05-29-worktree-lifecycle-design.md
- * Q-resolutions baked in (SPEC-APPROVED 3a80412d):
- *   Q1 branch naming  — `wt-<suffix>` prefix-stripped, full-basename fallback.
- *   Q2 idle-sync      — ff-only, clean-gated; never merge/rebase; never over dirty.
- *   Q3 post-merge     — auto-return to wt-<basename>; ANNOUNCE the prunable
- *                       merged branch, prune only when explicitly requested.
- *   Q4 uniform        — no primary-worktree carve-out; main is never a working branch.
- */
-/**
- * Per-worktree branch name (Q1). Strips the repo basename prefix from the
- * worktree dir basename for readability (`borg-mcp-codex-builder` ->
- * `wt-codex-builder`); falls back to the full dir basename when there is
- * no shared prefix (`myrepo-feature` under repo `otherrepo` ->
- * `wt-myrepo-feature`).
- */
-export function perWorktreeBranchName(worktreeBasename, repoBasename) {
-    const prefix = `${repoBasename}-`;
-    const suffix = worktreeBasename.startsWith(prefix)
-        ? worktreeBasename.slice(prefix.length)
-        : worktreeBasename;
-    return `wt-${suffix}`;
-}
-/** True iff the working tree is clean (`git status --porcelain` empty). */
-export function isCleanTree(runSync, cwd) {
-    const r = runSync('git', ['status', '--porcelain'], cwd);
-    return r.status === 0 && r.stdout.trim() === '';
-}
-const LOCAL_CONFIG_RE = /^\.claude\//;
-/**
- * Classify a dirty tree into staged / unstaged / untracked buckets, and
- * flag local-config files separately. The STAGED bucket is load-bearing:
- * the live UNBLOCK case (b15894be) had a *staged* leftover diff that
- * blocked `pull --ff-only`, which an unstaged-only check would miss.
- */
-export function classifyDirty(runSync, cwd) {
-    const r = runSync('git', ['status', '--porcelain'], cwd);
-    const out = { staged: [], unstaged: [], untracked: [], localConfig: [] };
-    if (r.status !== 0)
-        return out;
-    for (const line of r.stdout.split('\n')) {
-        if (!line.trim())
-            continue;
-        const path = line.slice(3);
-        if (line.startsWith('??')) {
-            out.untracked.push(path);
-        }
-        else {
-            const x = line[0]; // staged (index) column
-            const y = line[1]; // unstaged (work-tree) column
-            if (x !== ' ' && x !== '?')
-                out.staged.push(path);
-            if (y !== ' ' && y !== '?')
-                out.unstaged.push(path);
-        }
-        if (LOCAL_CONFIG_RE.test(path))
-            out.localConfig.push(path);
-    }
-    return out;
-}
-/** True iff `branch` is an ancestor of `ref` — i.e. a clean fast-forward target. */
-export function isFastForward(runSync, cwd, branch, ref) {
-    return runSync('git', ['merge-base', '--is-ancestor', branch, ref], cwd).status === 0;
-}
-/** True iff `branch`'s tip is an ancestor of `ref` — i.e. fully merged into it. */
-export function isMerged(runSync, cwd, branch, ref) {
-    return runSync('git', ['merge-base', '--is-ancestor', branch, ref], cwd).status === 0;
-}
-/**
- * Idle-sync the current per-worktree branch to `ref` (Q2). NEVER discards
- * work: dirty -> skipped-dirty (no mutation). Only fast-forwards (no
- * merge/rebase): diverged -> skipped-diverged. The caller fetches first.
- *
- * `already-current` when the branch tip already equals `ref` (the common
- * no-op case on every launch).
- */
-export function syncWorktree(runSync, cwd, branch, ref) {
-    if (!isCleanTree(runSync, cwd)) {
-        return {
-            action: 'skipped-dirty',
-            message: 'uncommitted changes present; sync skipped (nothing discarded)',
-        };
-    }
-    if (!isFastForward(runSync, cwd, branch, ref)) {
-        return {
-            action: 'skipped-diverged',
-            message: `${branch} has diverged from ${ref}; resolve manually (no auto-merge/rebase)`,
-        };
-    }
-    // Already at ref? merge --ff-only is a no-op but we report it distinctly
-    // so callers can stay quiet on the common case.
-    const ahead = runSync('git', ['rev-list', '--count', `${branch}..${ref}`], cwd);
-    if (ahead.status === 0 && ahead.stdout.trim() === '0') {
-        return { action: 'already-current' };
-    }
-    const ff = runSync('git', ['merge', '--ff-only', ref], cwd);
-    if (ff.status !== 0) {
-        return { action: 'skipped-diverged', message: 'ff-only merge unexpectedly failed' };
-    }
-    return { action: 'fast-forwarded' };
-}
-/** True iff a local branch named `branch` already exists. */
-export function localBranchExists(runSync, cwd, branch) {
-    return runSync('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], cwd).status === 0;
-}
-/**
- * Migration (Q4/Q5/§4.5): bring a detached/stale worktree onto
- * `wt-<basename>` at `ref`. Idempotent: re-running on an already-adopted
- * clean worktree is a lossless reset to `ref`. Never discards:
- *   - dirty work tree            -> skipped-dirty (surface)
- *   - current HEAD unmerged      -> blocked-unmerged (surface)
- *   - TARGET `branch` exists with commits not on `ref` -> blocked-target-
- *     unmerged (surface). This is load-bearing: the switch uses `-C`
- *     (force-create/reset), which would ORPHAN commits on a pre-existing
- *     `wt-` branch. The HEAD-merged check alone misses this when the
- *     target branch != HEAD (e.g. on `main` while a prior `wt-x` holds
- *     committed-but-unmerged work). gh#33 CR-v2 blocker 078d1630.
- */
-export function adoptWorktree(runSync, cwd, branch, ref) {
-    if (!isCleanTree(runSync, cwd)) {
-        return {
-            action: 'skipped-dirty',
-            message: 'uncommitted changes present; not switching (nothing discarded)',
-        };
-    }
-    if (!isMerged(runSync, cwd, 'HEAD', ref)) {
-        return {
-            action: 'blocked-unmerged',
-            message: `current HEAD has commits not on ${ref}; commit/push or set aside before adopting`,
-        };
-    }
-    // Guard the TARGET branch ref before the `switch -C` force-reset. If
-    // `branch` already exists and is NOT an ancestor of `ref`, it carries
-    // committed-unmerged work that `-C` would discard — block instead.
-    // (Absent, or an ancestor of `ref` = a clean reset target → proceed.)
-    if (localBranchExists(runSync, cwd, branch) && !isMerged(runSync, cwd, branch, ref)) {
-        return {
-            action: 'blocked-target-unmerged',
-            message: `branch ${branch} exists with commits not on ${ref}; resolve before adopting (a force-switch would discard them)`,
-        };
-    }
-    runSync('git', ['switch', '-C', branch, ref], cwd);
-    return { action: 'adopted' };
-}
-/**
- * Post-merge cleanup (Q3): when `feature` is fully merged into `ref`,
- * either ANNOUNCE it as prunable (default) or actually prune it with the
- * safe `git branch -d` (which itself refuses to delete an unmerged
- * branch — defense in depth against a stale local ref). Unmerged ->
- * not-merged (never touched).
- */
-export function cleanupMerged(runSync, cwd, feature, ref, opts = { prune: false }) {
-    if (!isMerged(runSync, cwd, feature, ref)) {
-        return { action: 'not-merged', branch: feature };
-    }
-    if (!opts.prune) {
-        return {
-            action: 'announced',
-            branch: feature,
-            message: `${feature} is merged into ${ref} and can be pruned: \`git branch -d ${feature}\` (or re-run with --prune)`,
-        };
-    }
-    runSync('git', ['branch', '-d', feature], cwd);
-    return { action: 'pruned', branch: feature };
-}
-//# sourceMappingURL=worktree-lifecycle.js.map
+function f(e,s){const t=`${s}-`;return`wt-${e.startsWith(t)?e.slice(t.length):e}`}function c(e,s){const t=e("git",["status","--porcelain"],s);return t.status===0&&t.stdout.trim()===""}const d=/^\.claude\//;function l(e,s){const t=e("git",["status","--porcelain"],s),i={staged:[],unstaged:[],untracked:[],localConfig:[]};if(t.status!==0)return i;for(const n of t.stdout.split(`
+`)){if(!n.trim())continue;const r=n.slice(3);if(n.startsWith("??"))i.untracked.push(r);else{const a=n[0],u=n[1];a!==" "&&a!=="?"&&i.staged.push(r),u!==" "&&u!=="?"&&i.unstaged.push(r)}d.test(r)&&i.localConfig.push(r)}return i}function g(e,s,t,i){return e("git",["merge-base","--is-ancestor",t,i],s).status===0}function o(e,s,t,i){return e("git",["merge-base","--is-ancestor",t,i],s).status===0}function m(e,s,t,i){if(!c(e,s))return{action:"skipped-dirty",message:"uncommitted changes present; sync skipped (nothing discarded)"};if(!g(e,s,t,i))return{action:"skipped-diverged",message:`${t} has diverged from ${i}; resolve manually (no auto-merge/rebase)`};const n=e("git",["rev-list","--count",`${t}..${i}`],s);return n.status===0&&n.stdout.trim()==="0"?{action:"already-current"}:e("git",["merge","--ff-only",i],s).status!==0?{action:"skipped-diverged",message:"ff-only merge unexpectedly failed"}:{action:"fast-forwarded"}}function p(e,s,t){return e("git",["rev-parse","--verify","--quiet",`refs/heads/${t}`],s).status===0}function h(e,s,t,i){return c(e,s)?o(e,s,"HEAD",i)?p(e,s,t)&&!o(e,s,t,i)?{action:"blocked-target-unmerged",message:`branch ${t} exists with commits not on ${i}; resolve before adopting (a force-switch would discard them)`}:(e("git",["switch","-C",t,i],s),{action:"adopted"}):{action:"blocked-unmerged",message:`current HEAD has commits not on ${i}; commit/push or set aside before adopting`}:{action:"skipped-dirty",message:"uncommitted changes present; not switching (nothing discarded)"}}function x(e,s,t,i,n={prune:!1}){return o(e,s,t,i)?n.prune?(e("git",["branch","-d",t],s),{action:"pruned",branch:t}):{action:"announced",branch:t,message:`${t} is merged into ${i} and can be pruned: \`git branch -d ${t}\` (or re-run with --prune)`}:{action:"not-merged",branch:t}}export{h as adoptWorktree,l as classifyDirty,x as cleanupMerged,c as isCleanTree,g as isFastForward,o as isMerged,p as localBranchExists,f as perWorktreeBranchName,m as syncWorktree};