borgmcp 2.16.1 → 3.0.2

package/src/remote-client.ts

@@ -95,16 +95,22 @@ export const LOCAL_SERVER_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_SERVER_RESPONSE_LIMIT_MESSAGE =
   'Local Borg server response exceeded the response limit';
 
+export const SERVER_ADVISORY_MAX_CHARS = 512;
+// Keep enough source headroom to remove control sequences that cross the
+// visible 512-character boundary without letting regex work scale with the
+// 32 MiB response-body limit.
+const SERVER_MESSAGE_SANITIZE_MAX_CHARS = SERVER_ADVISORY_MAX_CHARS * 8;
+
 function sanitizeServerMessage(message: string): string {
-  return message
-    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, '')
-    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+  const bounded = message.slice(0, SERVER_MESSAGE_SANITIZE_MAX_CHARS);
+
+  return bounded
+    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\|$)/g, '')
+    .replace(/\u001b\[[0-?]*[ -/]*(?:[@-~]|$)/g, '')
     .replace(/[\u0000-\u001f\u007f-\u009f]/g, '')
     .replace(/\\u(?:000[0-9a-f]|001[0-9a-f]|007f|008[0-9a-f]|009[0-9a-f])/gi, '');
 }
 
-export const SERVER_ADVISORY_MAX_CHARS = 512;
-
 export function sanitizeServerAdvisory(value: unknown): string | undefined {
   if (typeof value !== 'string') return undefined;
   const sanitized = sanitizeServerMessage(value).trim();
@@ -474,7 +480,7 @@ async function localCubeComposition(active: ActiveCube): Promise<{
   const drones = dronePayload.drones.map(withValidatedRuntimeMetadata);
   const drone = drones.find((candidate) => candidate.id === active.droneId);
   const role = rolePayload.roles.find((candidate) => candidate.id === drone?.role_id);
-  if (!drone || !role) throw new Error('Local Borg server no longer recognizes this drone seat');
+  if (!drone || !role) throw new Error('Local Borg server no longer recognizes this drone');
   return {
     cube: cubePayload.cube,
     roles: rolePayload.roles,

package/src/repository-cube-init.ts

@@ -169,7 +169,7 @@ function renderResult(
       `Next: borg assimilate --host ${shellEscape(input.serverOrigin)}`,
     );
   } else {
-    lines.push('Continuing with role and seat setup…');
+    lines.push('Continuing with role and connection setup…');
   }
   resultWriter(`${lines.join('\n')}\n`);
 }

package/src/reset-local-seat-cmd.ts

@@ -1,5 +1,5 @@
 /**
- * `borg reset-local-seat [--host <host>] [--yes]` — the dedicated LOCAL/OFFLINE
+ * `borg reset-local-connection [--host <host>] [--yes]` — the dedicated LOCAL/OFFLINE
  * seat reset from the ratified client-seat-reset-state-model (Option W).
  *
  * Attach is PURE DIAGNOSIS on a pin-matched SESSION_REJECTED (it mutates
@@ -95,7 +95,7 @@ export async function runResetLocalSeat(
   const snapshot = await deps.snapshotLocalSeat();
   if (!snapshot) {
     deps.stdout(
-      `No saved local seat was found for this worktree (${worktree}); nothing to reset.\n`,
+      `No saved connection was found for this worktree (${worktree}); nothing to reset.\n`,
     );
     return 0;
   }
@@ -105,9 +105,9 @@ export async function runResetLocalSeat(
   // operator asked to reset.
   if (requestedHost !== undefined && requestedHost !== snapshot.apiUrl) {
     deps.stdout(
-      `This worktree's saved local seat is on ${snapshot.apiUrl}, not ${requestedHost}; ` +
-        `nothing was changed. Re-run \`borg reset-local-seat --host ${snapshot.apiUrl}\` to ` +
-        "reset this worktree's seat.\n",
+      `This worktree connects to ${snapshot.apiUrl}, not ${requestedHost}; ` +
+        `nothing was changed. Re-run \`borg reset-local-connection --host ${snapshot.apiUrl}\` to ` +
+        "reset this worktree's saved connection.\n",
     );
     return 0;
   }
@@ -117,7 +117,7 @@ export async function runResetLocalSeat(
       ? `a saved local session credential is present (${snapshot.observation.state})`
       : 'the saved local session credential is already cleared (only the binding remains)';
   deps.stderr(
-    `This will clear ONLY this worktree's saved local seat on ${snapshot.apiUrl} ` +
+    `This will clear ONLY this worktree's saved connection to ${snapshot.apiUrl} ` +
       `(worktree ${worktree}) — ${observed}. Server, trust anchor, cube, and sibling ` +
       'worktrees are left untouched. It makes no network call and revokes nothing server-side.\n',
   );
@@ -125,17 +125,17 @@ export async function runResetLocalSeat(
   // ----- S1: consent OUTSIDE any lock -----
   if (deps.isTTY()) {
     const answer = await deps.prompt(
-      `Reset this worktree's saved local seat now? [y/N]: `,
+      `Reset this worktree's saved connection now? [y/N]: `,
     );
     const normalized = answer.trim().toLowerCase();
     if (normalized !== 'y' && normalized !== 'yes') {
-      deps.stderr("audit: no changes made — this worktree's saved seat was left in place.\n");
+      deps.stderr("audit: no changes made — this worktree's saved connection was left in place.\n");
       return 0;
     }
   } else if (flags.yes !== true) {
     deps.stderr(
       'audit: no changes made — stdin is non-interactive and --yes was not passed. Re-run ' +
-        '`borg reset-local-seat --yes` to clear this worktree\'s saved seat without a prompt.\n',
+        '`borg reset-local-connection --yes` to clear this worktree\'s saved connection without a prompt.\n',
     );
     return 1;
   }
@@ -146,7 +146,7 @@ export async function runResetLocalSeat(
     outcome = await deps.resetLocalSeatBinding(snapshot);
   } catch {
     deps.stderr(
-      `audit: no changes made — the local seat reset for ${snapshot.apiUrl} (worktree ` +
+      `audit: no changes made — the connection reset for ${snapshot.apiUrl} (worktree ` +
         `${worktree}) could not complete (local credential store error). Retry — it is ` +
         'safe to re-run.\n',
     );
@@ -155,7 +155,7 @@ export async function runResetLocalSeat(
 
   if (outcome.outcome === 'reset') {
     deps.stderr(
-      `audit: this worktree's saved local seat for ${snapshot.apiUrl} (worktree ${worktree}) ` +
+      `audit: this worktree's saved connection to ${snapshot.apiUrl} (worktree ${worktree}) ` +
         'was cleared; server, trust anchor, cube, and sibling worktrees unchanged.\n',
     );
     let remaining: Awaited<ReturnType<ResetLocalSeatDeps['findRemainingActiveSeat']>> = null;
@@ -167,9 +167,9 @@ export async function runResetLocalSeat(
     }
     if (remaining?.apiUrl === snapshot.apiUrl) {
       deps.stdout(
-        `Another saved active seat remains for this worktree on ${snapshot.apiUrl}. ` +
+        `Another saved connection remains for this worktree on ${snapshot.apiUrl}. ` +
           `Re-attach with ${reattachCommand(snapshot.apiUrl)}; Borg will revalidate that ` +
-          'seat with the server before launch.\n',
+          'it with the server before launch.\n',
       );
     } else {
       deps.stdout(recoveryGuidance(snapshot.apiUrl));
@@ -179,7 +179,7 @@ export async function runResetLocalSeat(
 
   if (outcome.outcome === 'no-binding') {
     deps.stdout(
-      `No saved local seat remained for this worktree (${worktree}); nothing to reset.\n`,
+      `No saved connection remained for this worktree (${worktree}); nothing to reset.\n`,
     );
     return 0;
   }
@@ -188,7 +188,7 @@ export async function runResetLocalSeat(
   // (a concurrent re-enroll wrote a fresh bearer, or another process already
   // reset it). Never clobber a replacement — report the honest no-op.
   deps.stdout(
-    `This worktree's saved local seat on ${snapshot.apiUrl} changed since it was read ` +
+    `This worktree's saved connection to ${snapshot.apiUrl} changed since it was read ` +
       "(a concurrent re-enroll or reset); nothing was changed. Re-run to observe the current " +
       'state.\n',
   );
@@ -221,7 +221,7 @@ export type ResetLocalSeatParseResult =
   | { ok: true; flags: ResetLocalSeatFlags }
   | { ok: false; error: string };
 
-/** Parse args after `borg reset-local-seat`. Supports `--host <h>` / `--host=<h>` / `--yes` / `-y`. */
+/** Parse args after `borg reset-local-connection`. Supports `--host <h>` / `--host=<h>` / `--yes` / `-y`. */
 export function parseResetLocalSeatArgs(rawArgs: string[]): ResetLocalSeatParseResult {
   const flags: ResetLocalSeatFlags = {};
   for (let i = 0; i < rawArgs.length; i += 1) {
@@ -244,7 +244,7 @@ export function parseResetLocalSeatArgs(rawArgs: string[]): ResetLocalSeatParseR
     } else {
       return {
         ok: false,
-        error: `unexpected argument: ${arg}. Usage: borg reset-local-seat [--host <host>] [--yes]`,
+        error: `unexpected argument: ${arg}. Usage: borg reset-local-connection [--host <host>] [--yes]`,
       };
     }
   }

package/src/seat-reattach-guard.ts

@@ -76,7 +76,7 @@ export function formatSeatReattachRefusal(
       ? ''
       : ` Its heartbeat is ${holder.heartbeat}, so the process may be wedged.`;
   return (
-    `This worktree's Borg seat already has a live session (inbox monitor pid ${holder.pid}).${heartbeat}\n` +
+    `This worktree's Borg drone already has a live session (inbox monitor pid ${holder.pid}).${heartbeat}\n` +
     'No agent was launched. Stop the existing session or use a fresh worktree with `borg assimilate --worktree <name>`. ' +
     `If the live monitor is wedged, override once with \`${forcedCommand}\`.\n`
   );

package/src/seat-store.ts

@@ -165,7 +165,7 @@ function staleLockError(lockPath: string, held: LockPayload | null): Error {
     ? `its recorded owner process (pid ${held.pid}, started ${held.startTime}) is no longer running`
     : 'its lock file is missing a valid owner identity or is corrupt';
   return new Error(
-    `Borg seat store lock file ${lockPath} is stale: ${who}. ` +
+    `Borg private store lock file ${lockPath} is stale: ${who}. ` +
       'Borg will NOT remove it automatically. If no borg process is running on this ' +
       `machine, delete ${lockPath} and retry; otherwise wait for the other borg process to finish.`,
   );
@@ -263,7 +263,7 @@ async function assertSecureStorePerms(
 ): Promise<void> {
   if ((fileMode & 0o077) !== 0) {
     throw new Error(
-      `Borg seat store file ${filePath} has insecure permissions ` +
+      `Borg private store file ${filePath} has insecure permissions ` +
         `(0${(fileMode & 0o777).toString(8)}, expected 0600); refusing to read a credential from it`,
     );
   }
@@ -277,7 +277,7 @@ async function assertSecureStorePerms(
   }
   if ((dirStat.mode & 0o077) !== 0) {
     throw new Error(
-      `Borg seat store directory ${dir} has insecure permissions ` +
+      `Borg private store directory ${dir} has insecure permissions ` +
         `(0${(dirStat.mode & 0o777).toString(8)}, expected 0700); refusing to read a credential under it`,
     );
   }
@@ -350,7 +350,7 @@ export async function readStoreFile(
  * release it on EVERY path (finally) by unlinking OUR OWN lock. Acquire is an atomic
  * `open(lockPath,'wx',0o600)`. On EEXIST the lock is held:
  *   - holder PID ALIVE → bounded wait/retry (attempts×waitMs), then throw the truthful
- *     transient 'Borg seat store is busy' error;
+ *     transient 'Borg private store is busy' error;
  *   - holder PID DEAD, or the payload is missing/unparseable → FAIL CLOSED naming the
  *     exact lockfile path + the recorded dead pid/start-time. Borg NEVER auto-deletes
  *     or steals it (no reclaim, no rename-claim). The operator clears it by hand only
@@ -422,7 +422,7 @@ export async function withStoreLock<T>(
         });
       }
     }
-    throw new Error('Borg seat store is busy');
+    throw new Error('Borg private store is busy');
   } finally {
     await unlink(tmp).catch(() => {});
   }
@@ -469,7 +469,7 @@ export async function withStore<S, T>(
       }
       if (loaded === null) {
         throw new Error(
-          'Borg seat store is malformed or has an unsupported version; refusing to overwrite it',
+          'Borg private store is malformed or has an unsupported version; refusing to overwrite it',
         );
       }
       data = loaded;

package/src/seats.ts

@@ -242,7 +242,7 @@ async function readStore(): Promise<SeatsFile> {
   const parsed = parseStore(raw);
   if (parsed === null) {
     throw new Error(
-      'Borg seat store is malformed or has an unsupported version; refusing to read it',
+      'Borg private store is malformed or has an unsupported version; refusing to read it',
     );
   }
   return parsed;

package/src/server-handshake.ts

@@ -338,7 +338,7 @@ export async function sendBorgServerAttach(
         if (rejectedCode === ErrorCode.SESSION_REJECTED) {
           throw new BorgServerError(
             'SESSION_REJECTED',
-            'Borg server rejected the session: the seat is already bound to another session',
+            'Borg server rejected the session: this worktree\'s connection is already bound to another session',
           );
         }
         if (rejectedCode === ErrorCode.SESSION_REVOKED) {

package/src/stream-status.ts

@@ -163,7 +163,7 @@ export function renderStreamStatus(inputs: RenderInputs): string {
   } else if (ownedByOther) {
     const owner = status.ownership!;
     summary = owner.droneLabel && owner.worktree
-      ? `**Stream owned by seat ${owner.droneLabel} in \`${owner.worktree}\`.**`
+      ? `**Stream owned by ${owner.droneLabel} in \`${owner.worktree}\`.**`
       : '**Stream owned by another Borg MCP process.**';
   } else if (isNotStarted) {
     summary = '**Stream not started.**';
@@ -248,7 +248,7 @@ export function renderStreamStatus(inputs: RenderInputs): string {
 
   if (ownedByOther) {
     const owner = status.ownership!;
-    lines.push(`- **stream owner seat**: ${owner.droneLabel ?? '_(unknown)_'}`);
+    lines.push(`- **stream owner**: ${owner.droneLabel ?? '_(unknown)_'}`);
     lines.push(`- **stream owner worktree**: ${owner.worktree ?? '_(unknown)_'}`);
     lines.push(`- **stream owner pid**: ${owner.pid ?? '_(unknown)_'}`);
     lines.push(`- **stream owner cwd**: ${owner.cwd ?? '_(unknown)_'}`);
@@ -260,7 +260,7 @@ export function renderStreamStatus(inputs: RenderInputs): string {
       }`
     );
     lines.push('');
-    lines.push('Continue in the owning seat, or close its duplicate agent session before relaunching from the intended worktree. The live owner releases this lock on exit; a stale lock is reclaimed automatically.');
+    lines.push('Continue as the owning drone, or close its duplicate agent session before relaunching from the intended worktree. The live owner releases this lock on exit; a stale lock is reclaimed automatically.');
   }
 
   if (wakePath.agentKind === 'opencode' && wakePath.openCode) {

package/src/tool-manifest.ts

@@ -506,7 +506,7 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         {
           name: 'borg_evict-drone',
           description:
-            'Remove a drone using the selected local client\'s cube-management grant. The seat credential is revoked, project files remain, and activity history keeps the removed seat\'s attribution. Accepts drone_id for the current cube or label with cube_id.',
+            'Remove a drone using the selected local client\'s cube-management grant. The drone\'s credential is revoked, project files remain, and activity history keeps the removed drone\'s attribution. Accepts drone_id for the current cube or label with cube_id.',
           inputSchema: {
             type: 'object',
             properties: {

package/src/unknown-subcommand.ts

@@ -16,10 +16,9 @@ export const KNOWN_SUBCOMMANDS = [
   'setup',
   'update',
   'assimilate',
-  'reset-local-seat',
+  'reset-local-connection',
   'recover-enrollment',
   'spawn',
-  'sync',
   'cleanup',
   'launch-all',
   'server',

package/src/worktree-lifecycle.ts

@@ -9,7 +9,6 @@
  * 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.
@@ -119,55 +118,11 @@ export function classifyDirty(runSync: RunSync, cwd: string): DirtyClassificatio
   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;

package/dist/sync.d.ts

@@ -1,129 +0,0 @@
-/**
- * `borg sync` — worktree lifecycle management subcommand (gh#33).
- *
- * Reconciled to the per-worktree `wt-<suffix>` branch model (PR-B,
- * ruling ea643b33). Replaces the previous main-centric semantics
- * ("idle = on main"; "post-merge = checkout main") — under the approved
- * gh#33 model `main` is NEVER a working branch in any worktree; it is
- * purely the integration target. Every worktree works on a named
- * `wt-<suffix>` branch and `borg sync` keeps it current with
- * origin/main, returns to it after a feature branch merges, and absorbs
- * upstream into an in-progress feature branch — never touching `main`
- * as a checkout.
- *
- * All git mutation/decision logic is delegated to
- * `src/worktree-lifecycle.ts` (the seam PR-A added:
- * `adoptWorktree`, `syncWorktree`, `cleanupMerged`, `isMerged`,
- * `localBranchExists`) so the never-discard guards (dirty / unmerged
- * HEAD / unmerged target wt- branch) and the args-array subprocess
- * shape are shared, not duplicated.
- *
- * Lifecycle states:
- *   1. dirty             — uncommitted changes; refuse (never discard).
- *   2. on-wt             — on the per-worktree `wt-<suffix>` branch;
- *                          fast-forward it to origin/main (ff-only).
- *   3. on-main           — on `main`/`master` (or detached at a merged
- *                          point); adopt the `wt-<suffix>` branch
- *                          (Q4: main is never a working branch).
- *   4. feature-mid-sprint — on a feature branch not yet merged; absorb
- *                          origin/main into it via `git merge --no-edit`
- *                          (no rebase — cube workflow rule (a)) when
- *                          origin/main advanced; else no-op.
- *   5. feature-merged    — on a feature branch fully merged into
- *                          origin/main; return to `wt-<suffix>` and
- *                          ANNOUNCE the prunable feature branch (prune
- *                          only with `--prune`, Q3).
- *
- * Anti-features (intentional, unchanged):
- *   - No auto-stash / auto-commit / auto-discard on dirty tree.
- *   - No force-push, no rebase, no --force-with-lease.
- *   - No remote-branch deletion (Coordinator owns merge actions).
- *   - Local feature-branch deletion only on explicit `--prune` (Q3).
- */
-import { type RunSync } from './worktree-lifecycle.js';
-export interface SpawnSyncResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-}
-export interface SyncDeps {
-    /** Synchronous spawn — used for `git ...` invocations. */
-    runSync?: RunSync;
-    /** Inject for tests; defaults to `process.cwd()`. */
-    cwd?: () => string;
-    /** stderr sink — overridable for tests. */
-    stderr?: (line: string) => void;
-    /** stdout sink — overridable for tests. */
-    stdout?: (line: string) => void;
-}
-export interface SyncOptions {
-    /** Q3: prune a merged feature branch instead of only announcing it. */
-    prune: boolean;
-}
-/**
- * Resolve the per-worktree `wt-` branch for the current checkout,
- * DETERMINISTICALLY per worktree.
- *
- *   - current branch is already `wt-*` → that is the branch.
- *   - otherwise → derive `wt-<suffix>` from THIS worktree's directory
- *     basename minus the main worktree's (repo) basename prefix — the
- *     same `perWorktreeBranchName` derivation the spawn path uses, so
- *     the name matches what `borg assimilate --worktree` created.
- *
- * This must NOT list `git branch --list wt-*`: in linked worktrees the
- * local branch namespace is SHARED across all siblings (gh#33 CR-v2
- * blocker 32bc45da), so every drone's `wt-` branch is visible and a
- * "single match" heuristic is never satisfied in a real multi-drone
- * cube. The directory-derivation is unique per worktree and never
- * ambiguous. The first `worktree <path>` line of
- * `git worktree list --porcelain` is the main worktree (the repo dir);
- * its basename is the prefix to strip. For an independent clone the
- * main worktree IS this worktree, so the prefix == basename and the
- * result is `wt-<basename>` (no strip) — consistent with PR-A's
- * in-place adoption.
- */
-export declare function resolveWtBranch(runSync: RunSync, cwd: string, currentBranch: string): string;
-export type SyncState = {
-    kind: 'dirty';
-    files: string[];
-} | {
-    kind: 'on-wt';
-    branch: string;
-    wtBranch: string;
-} | {
-    kind: 'on-main';
-    branch: string;
-    wtBranch: string;
-} | {
-    kind: 'feature-mid-sprint';
-    branch: string;
-    wtBranch: string;
-    commits: number;
-} | {
-    kind: 'feature-merged';
-    branch: string;
-    wtBranch: string;
-} | {
-    kind: 'error';
-    reason: string;
-};
-/**
- * Detect the worktree's lifecycle state. Read-only except for the
- * `git fetch origin --prune` needed to measure against the latest tip.
- */
-export declare function detectState(deps: Required<SyncDeps>): SyncState;
-export declare function runSync(deps?: SyncDeps, opts?: SyncOptions): Promise<number>;
-export type ParseResult = {
-    ok: true;
-    options: SyncOptions;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Parse args after `borg sync`. Supports `--prune` (Q3: delete a merged
- * feature branch after returning to the wt- branch). Rejects anything
- * else to keep room for future flags.
- */
-export declare function parseSyncArgs(rawArgs: string[]): ParseResult;
-//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAKH,OAAO,EAML,KAAK,OAAO,EACb,MAAM,yBAAyB,CAAC;AAMjC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IAC1B,uEAAuE;IACvE,KAAK,EAAE,OAAO,CAAC;CAChB;AAsBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,GACpB,MAAM,CAaR;AAMD,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,SAAS,CAgE/D;AAMD,wBAAsB,OAAO,CAAC,IAAI,GAAE,QAAa,EAAE,IAAI,GAAE,WAA8B,GAAG,OAAO,CAAC,MAAM,CAAC,CAiFxG;AAiCD,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5F;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,CAa5D"}