borgmcp 1.1.14 → 2.0.1

package/src/tool-scope.ts

@@ -0,0 +1,110 @@
+/**
+ * gh#899: role-scope the NATIVE MCP tool surface to cut the per-call tool tax
+ * for simpler models. This is a token-surface UX / context optimization ONLY —
+ * it carries ZERO authorization semantics. Server enforcement uses the selected
+ * local client's live per-cube `read|write|manage` grant, independent of which
+ * tool schemas are pre-loaded. Reaching a management tool through the dispatcher
+ * bypasses no server check because it uses the identical CallTool path.
+ * Never treat this filter as a security boundary.
+ *
+ * Deferred (filtered-out) tools are never lost — they remain reachable through
+ * the always-present dispatcher (`borg_tool` / `borg_describe-tool`), so a
+ * scoped role can never dead-end.
+ */
+
+/** Always-present escape hatch — reaches any borg tool regardless of scope. */
+export const DISPATCHER_TOOLS = ['borg_tool', 'borg_describe-tool'] as const;
+
+/** Every role needs these; pre-loaded natively for all roles. */
+export const UNIVERSAL_TOOLS = [
+  'borg_regen',
+  'borg_log',
+  'borg_read-log',
+  'borg_roster',
+  'borg_stream-status',
+  'borg_whoami',
+  'borg_ack',
+  'borg_version',
+  'borg_cube',
+  'borg_role',
+  'borg_role-rationale',
+  'borg_assimilate',
+  'borg_playbook', // gh#912: on-demand operating-playbook chapter — every role needs it
+  'borg_docs', // gh#docs-site B: in-product docs lookup — every role can answer "how does borgmcp work"
+  ...DISPATCHER_TOOLS,
+] as const;
+
+/** Cube/role/drone management — native for management seats, deferred for workers. */
+export const MANAGEMENT_TOOLS = [
+  'borg_create-cube',
+  'borg_update-cube',
+  'borg_delete-cube',
+  'borg_create-role',
+  'borg_update-role',
+  'borg_delete-role',
+  'borg_patch-role-section',
+  'borg_patch-taxonomy-class',
+  'borg_reassign-drone',
+  'borg_evict-drone',
+  'borg_sync-roles',
+  'borg_apply-template',
+  'borg_list-cubes',
+  'borg_list-drones',
+  'borg_list-roles',
+  'borg_list-templates',
+  'borg_remove-decision',
+] as const;
+
+/**
+ * Highest-stakes subset of the management set — filtered from a worker's native
+ * surface for context economy only. NOT an auth list: server access is enforced
+ * by live per-client cube grants (`read|write|manage`) and is independent
+ * of this client-side UX filter. Role labels never grant server permission.
+ * Named here only to focus reviewer attention.
+ */
+export const AUTH_SENSITIVE_TOOLS = [
+  'borg_evict-drone',
+  'borg_delete-cube',
+  'borg_delete-role',
+  'borg_reassign-drone',
+] as const;
+
+export interface RoleScope {
+  /** The drone's role name, as persisted at assimilate. Absent → role unknown. */
+  roleName?: string | null;
+  roleClass?: 'queen' | 'worker' | null;
+  isHumanSeat?: boolean | null;
+}
+
+/** Management seats (human-seat roles + queen-class) get the full surface. */
+export function isManagementSeat(scope: RoleScope): boolean {
+  return scope.isHumanSeat === true || scope.roleClass === 'queen';
+}
+
+/**
+ * Names to HIDE from the native surface for this scope. Empty (hide nothing)
+ * when the role is unknown (no roleName — old cubes.json entry or pre-assimilate)
+ * or the caller is a management seat. Only a known worker role defers the
+ * management + billing sets. Fail-safe: anything not explicitly in a deferred
+ * set stays native.
+ */
+export function deferredToolNames(scope: RoleScope | null): Set<string> {
+  if (!scope || !scope.roleName) return new Set(); // role unknown → full set
+  if (isManagementSeat(scope)) return new Set(); // management seat → full set
+  return new Set<string>([...MANAGEMENT_TOOLS]); // worker → defer
+}
+
+/**
+ * Filter a tool-definition array down to the native surface for this scope.
+ * Tools whose name is in the deferred set are removed; everything else
+ * (universal, dispatcher, unmapped) stays. The deferred tools remain reachable
+ * via the dispatcher.
+ */
+export function filterToolsForRole<T extends { name: string }>(
+  tools: T[],
+  scope: RoleScope | null
+): T[] {
+  const hidden = deferredToolNames(scope);
+  if (hidden.size === 0) return tools;
+  return tools.filter((t) => !hidden.has(t.name));
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for Borg MCP Client
+ */
+
+export {};

package/src/unknown-subcommand.ts

@@ -0,0 +1,35 @@
+/**
+ * gh#911: top-level CLI footgun guard.
+ *
+ * `borg <unknown>` (e.g. `borg evict-drone X`) used to fall through the
+ * subcommand router, get ignored by parseCliFlag (which validates only
+ * `--cli`), and silently LAUNCH a Claude Code session with the typo'd word as
+ * its prompt — surprising + wasteful, and the trailing args were dropped.
+ *
+ * This pure predicate lets claude.ts reject an unknown NON-FLAG argv[2] before
+ * the default launch. Bare `borg` (no argv[2]) and recognized flags
+ * (`--cli`, `--remote`, agent passthrough, …) still fall through to launch.
+ */
+
+/** The subcommands the claude.ts router dispatches on (lines 107-176). */
+export const KNOWN_SUBCOMMANDS = [
+  'setup',
+  'assimilate',
+  'reset-local-seat',
+  'spawn',
+  'sync',
+  'cleanup',
+  'launch-all',
+] as const;
+
+/**
+ * Returns the offending command string when argv[2] is an unknown non-flag
+ * positional (caller should error + exit 1), or null when it's bare `borg`,
+ * a flag, or a known subcommand (caller falls through to existing handling).
+ */
+export function unknownSubcommand(argv2: string | undefined): string | null {
+  if (argv2 === undefined) return null; // bare `borg`
+  if (argv2.startsWith('-')) return null; // a flag → handled downstream
+  if ((KNOWN_SUBCOMMANDS as readonly string[]).includes(argv2)) return null;
+  return argv2; // unknown non-flag positional → footgun
+}

package/src/version.ts

@@ -0,0 +1,82 @@
+/**
+ * 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(): string {
+  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(): string {
+  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 setup 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(): string {
+  return readPackageVersion();
+}
+
+export function handleVersionFlag(): void {
+  if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    process.stdout.write(`borgmcp ${VERSION}\n`);
+    process.exit(0);
+  }
+}

package/src/working-repo.ts

@@ -0,0 +1,99 @@
+/**
+ * Resolve the repository identity for the directory hosting this MCP child.
+ *
+ * The report carries only a canonical repository identity (`host/org/repo`)
+ * and its derived name. Local filesystem paths and raw remote URLs are never
+ * included in lifecycle metadata.
+ */
+
+import { spawnSync } from 'node:child_process';
+export interface WorkingRepo {
+  name: string | null;
+  /** Canonical host/path identity, never a raw Git remote URL. */
+  origin: string | null;
+}
+
+export interface WorkingRepoDeps {
+  runGit?: (
+    cwd: string,
+    args: string[]
+  ) => { status: number | null; stdout?: string | null };
+}
+
+function defaultRunGit(cwd: string, args: string[]) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf-8' });
+  return { status: result.status, stdout: result.stdout };
+}
+
+function trimmed(value: string | null | undefined): string | null {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+
+function nameFromIdentity(identity: string): string | null {
+  const lastPathSegment = identity.replace(/\/$/, '').split('/').pop();
+  const name = lastPathSegment?.replace(/\.git$/i, '').trim();
+  return name || null;
+}
+
+/**
+ * Convert a Git remote to a non-secret `host/org/repo` identity.
+ *
+ * URL userinfo, query strings, fragments, scheme, and SCP-style user prefixes
+ * are deliberately discarded. Inputs that cannot identify a host and path are
+ * treated as unreportable rather than forwarded verbatim.
+ */
+export function canonicalizeWorkingRepoIdentity(origin: string): string | null {
+  const raw = origin.trim();
+  if (!raw) return null;
+  // Remote clients send this canonical form on subsequent lifecycle calls.
+  const canonical = raw.match(/^([A-Za-z0-9.-]+)\/([^?#\s]+)$/);
+  if (canonical) {
+    const host = canonical[1].toLowerCase();
+    const path = canonical[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+    return host && path ? `${host}/${path}` : null;
+  }
+  try {
+    const url = new URL(origin);
+    if (!['http:', 'https:', 'ssh:', 'git:'].includes(url.protocol)) return null;
+    const path = url.pathname.replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+    return url.hostname && path ? `${url.hostname.toLowerCase()}/${path}` : null;
+  } catch {
+    // SCP-style SSH remote: discard its optional user prefix and URL-like
+    // query/fragment suffix before accepting only host + repository path.
+    const match = raw.match(/^(?:[^@\s/:]+@)?([A-Za-z0-9.-]+):\/?([^?#\s]+)(?:[?#].*)?$/);
+    if (match) {
+      const host = match[1].toLowerCase();
+      const path = match[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+      return host && path ? `${host}/${path}` : null;
+    }
+    return null;
+  }
+}
+
+/**
+ * Return a reportable identity for the caller's current directory.
+ *
+ * `git rev-parse --show-toplevel` supports both ordinary clones and linked
+ * worktrees. Any git failure reports no repository identity instead of
+ * disclosing the caller's local filesystem layout.
+ */
+export function resolveWorkingRepo(
+  cwd: string = process.cwd(),
+  deps: WorkingRepoDeps = {}
+): WorkingRepo {
+  const runGit = deps.runGit ?? defaultRunGit;
+  const rootResult = runGit(cwd, ['rev-parse', '--show-toplevel']);
+  const root = rootResult.status === 0 ? trimmed(rootResult.stdout) : null;
+  if (!root) {
+    return { name: null, origin: null };
+  }
+
+  const originResult = runGit(cwd, ['config', '--get', 'remote.origin.url']);
+  const originRaw = originResult.status === 0 ? trimmed(originResult.stdout) : null;
+  const origin = originRaw ? canonicalizeWorkingRepoIdentity(originRaw) : null;
+  return {
+    name: origin ? nameFromIdentity(origin) : null,
+    origin,
+  };
+}

package/src/worktree-lifecycle.ts

@@ -0,0 +1,254 @@
+/**
+ * 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.
+ */
+
+import { join } from 'node:path';
+
+/** Injected subprocess runner — matches AssimilateDeps.runSync. */
+export type RunSync = (
+  cmd: string,
+  args: string[],
+  cwd?: string
+) => { status: number | null; stdout: string; stderr: string };
+
+/**
+ * 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: string, repoBasename: string): string {
+  const prefix = `${repoBasename}-`;
+  const suffix = worktreeBasename.startsWith(prefix)
+    ? worktreeBasename.slice(prefix.length)
+    : worktreeBasename;
+  return `wt-${suffix}`;
+}
+
+/**
+ * gh#556 Part 1 — the home for NEW drone worktrees: `<homeDir>/.borg/worktrees`.
+ * (`~/.borg` is the established borg home — it already holds the encrypted
+ * credentials file, see config.ts.)
+ */
+export function worktreesHome(homeDir: string): string {
+  return join(homeDir, '.borg', 'worktrees');
+}
+
+/**
+ * gh#556 Part 1 — where a NEW drone worktree lives:
+ * `<homeDir>/.borg/worktrees/<repoBase>/<suffix>` (collision variant `<suffix>-<n>`
+ * for n>=2; the caller loops n until the path is free).
+ *
+ * Pure (homeDir injected) so the path scheme + collision dedup + containment are
+ * unit-testable without touching $HOME or spawning git.
+ *
+ * Path-safety / no-traversal: `suffix` is validated upstream BEFORE it reaches here —
+ * `--worktree` via validateName (NAME_RE excludes `.`/`/`) or the role default via
+ * roleSlug (strips everything but `[a-z0-9-]`); `repoBase` is a single `basename(...)`
+ * component. So the result is always CONTAINED under `worktreesHome(homeDir)`.
+ * As defense-in-depth this throws on an EMPTY suffix — an empty leaf would let
+ * `join` collapse the path up to the repo-level dir (the degenerate-path bug); the
+ * caller also guards empty before calling, fail-loud.
+ */
+export function computeWorktreePath(
+  homeDir: string,
+  repoBase: string,
+  suffix: string,
+  n?: number
+): string {
+  if (suffix.length === 0) {
+    throw new Error('computeWorktreePath: suffix must be non-empty (empty leaf would collapse the path to the repo-level dir)');
+  }
+  const leaf = n !== undefined && n >= 2 ? `${suffix}-${n}` : suffix;
+  return join(worktreesHome(homeDir), repoBase, leaf);
+}
+
+/** True iff the working tree is clean (`git status --porcelain` empty). */
+export function isCleanTree(runSync: RunSync, cwd: string): boolean {
+  const r = runSync('git', ['status', '--porcelain'], cwd);
+  return r.status === 0 && r.stdout.trim() === '';
+}
+
+export interface DirtyClassification {
+  staged: string[];
+  unstaged: string[];
+  untracked: string[];
+  /** Subset that are local-only config (e.g. `.claude/...`) — likely safe to set aside. */
+  localConfig: string[];
+}
+
+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: RunSync, cwd: string): DirtyClassification {
+  const r = runSync('git', ['status', '--porcelain'], cwd);
+  const out: DirtyClassification = { 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: RunSync, cwd: string, branch: string, ref: string): boolean {
+  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: RunSync, cwd: string, branch: string, ref: string): boolean {
+  return runSync('git', ['merge-base', '--is-ancestor', branch, ref], cwd).status === 0;
+}
+
+export interface SyncResult {
+  action: 'fast-forwarded' | 'already-current' | 'skipped-dirty' | 'skipped-diverged';
+  message?: string;
+}
+
+/**
+ * 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: RunSync, cwd: string, branch: string, ref: string): SyncResult {
+  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' };
+}
+
+export interface AdoptResult {
+  action: 'adopted' | 'blocked-unmerged' | 'blocked-target-unmerged' | 'skipped-dirty';
+  message?: string;
+}
+
+/** True iff a local branch named `branch` already exists. */
+export function localBranchExists(runSync: RunSync, cwd: string, branch: string): boolean {
+  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: RunSync, cwd: string, branch: string, ref: string): AdoptResult {
+  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' };
+}
+
+export interface CleanupResult {
+  action: 'pruned' | 'announced' | 'not-merged';
+  /** The feature branch this result concerns (for the announce message). */
+  branch?: string;
+  message?: string;
+}
+
+/**
+ * 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: RunSync,
+  cwd: string,
+  feature: string,
+  ref: string,
+  opts: { prune: boolean } = { prune: false }
+): CleanupResult {
+  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 };
+}

package/dist/auth-recovery.d.ts

@@ -1,33 +0,0 @@
-/**
- * gh#780 companion fix: classify auth-class failures into the RIGHT
- * recovery advice for an in-session agent.
- *
- * Root-cause context: the pre-gh#780 funnel answered every auth failure by
- * pointing the user at `borg assimilate` (the wrong remedy; gh#794 now also
- * differentiates a dead saved login from never-signed-in, both → `borg setup`).
- * An in-session agent's only reachable assimilate is the borg_assimilate MCP tool, which
- * minted a brand-new drones row — so each auth blip spawned an orphan seat
- * (the gh#780 class). Neither failure mode is fixable by assimilating:
- * assimilate rides the same broken Bearer token.
- *
- *   - REVOKED / re-consent required (RefreshTokenInvalidError surfaced as
- *     "Authentication required/expired"): only `borg setup` in a terminal
- *     re-consents.
- *   - TRANSIENT refresh failure (RefreshTransientError, "Failed to
- *     refresh"): keychain intact by design (gh#34) — the next call
- *     retries; waiting IS the recovery.
- */
-interface AuthErrorLike {
-    name?: string;
-    message?: string;
-}
-/**
- * Returns the agent-facing recovery message for an auth-class error, or
- * null when the error is not auth-related (caller falls through to its
- * generic error rendering). Transient classification wins over the generic
- * auth-text match — a transient error's message may also mention
- * "Authentication".
- */
-export declare function authRecoveryMessage(error: AuthErrorLike): string | null;
-export {};
-//# sourceMappingURL=auth-recovery.d.ts.map

package/dist/auth-recovery.js

@@ -1 +0,0 @@
-function t(n){const e=n.message??"";return n.name==="RefreshTransientError"||e.includes("Failed to refresh")?"\u25FC Transient auth-refresh failure (network/Google hiccup). Your session is intact and auth self-recovers \u2014 retry the tool call in a moment. Do NOT re-assimilate: borg_assimilate cannot fix auth and would mint a duplicate drone seat.":e.includes("Authentication required")||e.includes("Authentication expired")?"\u25FC Authentication expired \u2014 re-consent needed. Run `borg setup` in a terminal to sign in again. Do NOT re-assimilate: borg_assimilate cannot fix auth and would mint a duplicate drone seat.":null}export{t as authRecoveryMessage};