borgmcp 2.16.0 → 3.0.0

package/src/cubes.ts

@@ -110,7 +110,7 @@ let pinnedMcpSeatIdentity: {
 export class McpSeatIdentityChangedError extends Error {
   readonly code = 'SEAT_IDENTITY_CHANGED';
   constructor() {
-    super('The saved Borg seat changed after this MCP session pinned its identity. Exit this session and relaunch from the intended worktree.');
+    super('This worktree\'s saved connection changed after this MCP session pinned its identity. Exit this session and relaunch from the intended worktree.');
     this.name = 'McpSeatIdentityChangedError';
   }
 }
@@ -439,7 +439,7 @@ export async function snapshotLocalSeat(): Promise<LocalSeatSnapshot | null> {
   // CR#4: discover an ACTIVE seat OR a bound-PENDING record (a sibling whose
   // activation failed, bound to THIS worktree by the attach bind-pending step).
   // getActiveSeatForWorktree would MISS the bound-pending record (it requires
-  // state==='active' + a drone id), so `reset-local-seat` would FALSELY report
+  // state==='active' + a drone id), so `reset-local-connection` would FALSELY report
   // "nothing to reset" (exit 0) while a resumable, server-digest-bound bearer
   // persists at rest — a FALSE-SUCCESS revocation failure. getSeatForWorktree sees
   // both, and the offline reset's exact re-check + delete cover the bound-pending

package/src/docs-sections.ts

@@ -78,7 +78,7 @@ export const DOCS_SECTIONS: DocsSection[] = [
     url: SEAT_LIFECYCLE_URL,
     page: "docs/SEAT_LIFECYCLE.md",
     summary: "Saved-seat states, re-attach and reset recovery, duplicate-session guards, and deterministic multi-seat selection.",
-    keywords: ["seat", "lifecycle", "reattach", "re-attach", "reset-local-seat", "evicted", "revoked", "superseded", "inbox monitor", "multiple seats", "silent deafness"],
+    keywords: ["seat", "lifecycle", "reattach", "re-attach", "reset-local-connection", "evicted", "revoked", "superseded", "inbox monitor", "multiple seats", "silent deafness"],
   },
   {
     slug: "self-hosting",

package/src/drone-lifecycle.ts

@@ -16,7 +16,7 @@ export const CUBE_DELETED_CODE = 'CUBE_DELETED';
 
 export class DroneEvictedError extends Error {
   constructor(
-    message = 'This seat was removed from the cube.'
+    message = 'This drone was removed from the cube.'
   ) {
     super(message);
     this.name = 'DroneEvictedError';
@@ -45,8 +45,8 @@ export const CUBE_DELETED_RESULT_MARKER = '[CUBE-DELETED]';
 export function formatEvictedToolResult(cubeName?: string): string {
   const cube = cubeName ?? 'the selected cube';
   return (
-    `${EVICTED_RESULT_MARKER} This seat was removed from cube ${cube}.\n\n` +
-    'Borg has stopped listening for activity for this seat. Do not retry this request or restart the loop.\n\n' +
+    `${EVICTED_RESULT_MARKER} This drone was removed from cube ${cube}.\n\n` +
+    'Borg has stopped listening for activity for this drone. Do not retry this request or restart the loop.\n\n' +
     'Your worktree and project files are unchanged. Finish any local file safety checks, then end this agent session.\n\n' +
     'To rejoin later, start a new session and use a new invitation from the server operator. Do not re-assimilate from this evicted session.'
   );

package/src/drone-management.ts

@@ -50,7 +50,7 @@ const defaultDeps: DroneManagementDeps = {
 };
 
 export const STALE_ROLE_DISPLAY_WARNING =
-  'Local display warning: The server committed this change, but Borg could not refresh this worktree\'s saved seat metadata. Local role details may be stale. Do not retry the reassignment.\n\n' +
+  'Local display warning: The server committed this change, but Borg could not refresh this worktree\'s saved connection metadata. Local role details may be stale. Do not retry the reassignment.\n\n' +
   'Run `borg_regen` to refresh the server-authoritative role. If this session still shows the previous role, restart this agent session once. Do not re-assimilate or repeat the management request.';
 
 function opaqueNotFound(): never {

package/src/evict-drone.ts

@@ -75,8 +75,8 @@ export function formatReassignDroneSuccess(input: {
 export function formatEvictDroneSuccess(droneLabel: string, cubeName: string): string {
   return (
     `Removed ${droneLabel} from cube ${cubeName}.\n` +
-    'The seat credential is revoked. The session will stop after its next Borg request.\n' +
-    'The worktree and project files were not deleted. Activity history remains attributed to the removed seat.\n' +
+    'The drone\'s credential is revoked. The session will stop after its next Borg request.\n' +
+    'The worktree and project files were not deleted. Activity history remains attributed to the removed drone.\n' +
     'After its work is merged, run `borg cleanup` to review whether the worktree can be pruned.'
   );
 }

package/src/foreign-path-reminder.ts

@@ -17,7 +17,7 @@ import {
   BORG_LAUNCH_WORKTREE_ENV,
 } from './launch-access.js';
 
-const REMINDER = 'Reminder: this seat is scoped to its own worktree and scratch root; coordinate before working on a foreign path.';
+const REMINDER = 'Reminder: this drone is scoped to its own worktree and scratch root; coordinate before working on a foreign path.';
 
 const PATH_KEYS = new Set([
   'cwd',

package/src/inbox-monitor.ts

@@ -797,8 +797,8 @@ function liveMonitorYieldLine(
     : null;
   const holder = livePid === null ? 'another monitor instance' : `a live instance (pid ${livePid})`;
   return (
-    `borg-inbox-monitor: seat inbox ${JSON.stringify(inboxPath)} is already monitored by ${holder}; ` +
-    'yielding — another session likely holds this seat.'
+    `borg-inbox-monitor: inbox ${JSON.stringify(inboxPath)} is already monitored by ${holder}; ` +
+    'yielding — another session likely holds this worktree\'s connection.'
   );
 }
 

package/src/index.ts

@@ -561,7 +561,7 @@ export async function main() {
               `# Re-attached to cube: ${displayIdentity.cubeName}`,
               ``,
               `**Drone label:** ${displayIdentity.droneLabel}`,
-              `**Seat:** existing identity reused — no new drone minted (gh#780)`,
+              `**Drone:** existing identity reused — no new drone minted (gh#780)`,
               ``,
               ``,
             ].join('\n');

package/src/launch-all-cmd.ts

@@ -53,7 +53,7 @@ async function resolveTargetCube(
     const identities = await deps.readAllProjectIdentities();
     const matches = identities.filter((e) => e.cube.name === args.cubeName);
     if (matches.length === 0) {
-      return { error: `no cube named '${args.cubeName}' found among this machine's saved seats — has any drone assimilated into it?` };
+      return { error: `no cube named '${args.cubeName}' found among this machine's saved connections — has any drone assimilated into it?` };
     }
     // gh#850: distinct cubes can share a name (same name across accounts/
     // environments, or a stale seat). Silently taking matches[0] could launch
@@ -61,13 +61,13 @@ async function resolveTargetCube(
     // cubeId + the project that holds the seat and refuse to guess.
     if (matches.length > 1) {
       const list = matches
-        .map((m) => `  ${m.cube.cubeId}  (seat in ${m.projectPath})`)
+        .map((m) => `  ${m.cube.cubeId}  (drone in ${m.projectPath})`)
         .join('\n');
       return {
         error:
-          `'${args.cubeName}' is ambiguous — ${matches.length} saved seats on this machine share that name:\n${list}\n` +
+          `'${args.cubeName}' is ambiguous — ${matches.length} saved connections on this machine share that name:\n${list}\n` +
           'cd into the intended project and re-run without --cube-name (resolves the active cube), ' +
-          'or clear the stale seat(s) by running `borg reset-local-seat` from the worktree that holds each.',
+          'or clear the stale connection(s) by running `borg reset-local-connection` from the worktree that holds each.',
       };
     }
     return { cubeId: matches[0].cube.cubeId, name: args.cubeName };
@@ -237,7 +237,7 @@ export async function runLaunchAll(
       }
     } else {
       deps.stdout(
-        `No worktrees found for cube '${cubeName}' — have you run \`borg assimilate --worktree\` to create any drone seats?\n`
+        `No worktrees found for cube '${cubeName}' — have you run \`borg assimilate --worktree\` to create any drones?\n`
       );
     }
     return 0;
@@ -290,8 +290,8 @@ export async function runLaunchAll(
     if (status === 'evicted') {
       evictedCount += 1;
       deps.stderr(
-        `skipping ${c.droneLabel} (${c.worktreeDir}): seat no longer in cube (evicted) — ` +
-          `run \`borg cleanup --prune\` to remove the worktree, or \`borg assimilate\` to re-seat fresh.\n`
+        `skipping ${c.droneLabel} (${c.worktreeDir}): drone no longer in cube (evicted) — ` +
+          `run \`borg cleanup --prune\` to remove the worktree, or \`borg assimilate\` to start fresh.\n`
       );
       continue;
     }
@@ -299,7 +299,7 @@ export async function runLaunchAll(
       revokedCount += 1;
       deps.stderr(
         `Local session was revoked.\n` +
-          `Next: run borg reset-local-seat, then borg assimilate --host ${c.apiUrl} --enroll.\n`
+          `Next: run borg reset-local-connection, then borg assimilate --host ${c.apiUrl} --enroll.\n`
       );
       continue;
     }
@@ -307,7 +307,7 @@ export async function runLaunchAll(
       rejectedCount += 1;
       deps.stderr(
         `Local session was superseded by a newer enrollment.\n` +
-          `Next: run borg reset-local-seat, then borg assimilate --host ${c.apiUrl} --enroll.\n`
+          `Next: run borg reset-local-connection, then borg assimilate --host ${c.apiUrl} --enroll.\n`
       );
       continue;
     }
@@ -336,7 +336,7 @@ export async function runLaunchAll(
     // cause-accurate note. Only the authoritative/terminal causes above skip.
     if (status === 'unreachable') {
       deps.stderr(
-        `note: could not reach ${c.droneLabel}'s server to confirm its seat (network/timeout) — launching anyway.\n`
+        `note: could not reach ${c.droneLabel}'s server to confirm that drone (network/timeout) — launching anyway.\n`
       );
     } else if (status === 'endpoint-mismatch') {
       deps.stderr(
@@ -344,11 +344,11 @@ export async function runLaunchAll(
       );
     } else if (status === 'server-failure') {
       deps.stderr(
-        `note: ${c.droneLabel}'s server returned an error while confirming its seat (transient) — launching anyway.\n`
+        `note: ${c.droneLabel}'s server returned an error while confirming that drone (transient) — launching anyway.\n`
       );
     } else if (status === 'indeterminate') {
       deps.stderr(
-        `note: could not confirm ${c.droneLabel}'s seat is live (network/transient) — launching anyway.\n`
+        `note: could not confirm ${c.droneLabel} is live (network/transient) — launching anyway.\n`
       );
     }
     launchable.push(c);

package/src/launch-all-discovery.ts

@@ -95,7 +95,7 @@ export async function discoverDroneCandidates(
     // 4. malformed entry (cubeId/droneId not UUID) → warn + skip
     if (!isUuid(cube.cubeId) || !isUuid(cube.droneId)) {
       deps.stderr(
-        `skipping ${worktreeDir}: its saved seat has a malformed cubeId/droneId — re-assimilate to fix\n`
+        `skipping ${worktreeDir}: its saved connection has a malformed cubeId/droneId — re-assimilate to fix\n`
       );
       continue;
     }

package/src/opencode-seat-identity.ts

@@ -71,14 +71,14 @@ export async function resolveOpenCodeSeatIdentity(
   if (!active) {
     throw new OpenCodeSeatIdentityError(
       'SEAT_NOT_FOUND',
-      'No active Borg seat is bound to the OpenCode session directory.',
+      'No Borg drone is bound to the OpenCode session directory.',
       sessionWorktree,
     );
   }
   if (typeof active.worktree !== 'string' || resolve(active.worktree) !== resolve(sessionWorktree)) {
     throw new OpenCodeSeatIdentityError(
       'SEAT_WORKTREE_MISMATCH',
-      'The resolved Borg seat belongs to a different worktree than the OpenCode session.',
+      'The resolved Borg drone belongs to a different worktree than the OpenCode session.',
       sessionWorktree,
       active,
     );
@@ -93,19 +93,19 @@ export function formatOpenCodeSeatIdentityError(
   childCwd: string,
 ): string {
   const lines = [
-    `Borg OpenCode seat identity error [${error.code}]`,
+    `Borg OpenCode identity error [${error.code}]`,
     '',
     error.message,
     `- OpenCode session directory: ${error.sessionDirectory ?? 'unavailable'}`,
     `- Borg MCP child cwd: ${childCwd}`,
   ];
   if (error.seat) {
-    lines.push(`- Resolved seat: ${error.seat.droneLabel} (${error.seat.worktree})`);
+    lines.push(`- Resolved drone: ${error.seat.droneLabel} (${error.seat.worktree})`);
   }
   lines.push(
     '',
     'The Borg stream and OpenCode wake injection were not started.',
-    'Exit this session and run `borg --cli opencode` from the intended worktree. If that worktree’s saved seat is stale, run `borg reset-local-seat` from that exact worktree before assimilating again.',
+    'Exit this session and run `borg --cli opencode` from the intended worktree. If that worktree\'s saved connection is stale, run `borg reset-local-connection` from that exact worktree before assimilating again.',
   );
   return lines.join('\n');
 }

package/src/regen-format.ts

@@ -6,6 +6,7 @@
  * index.ts's stdio MCP server bootstrap.
  */
 
+import { hostname as osHostname } from 'node:os';
 import {
   ROLE_SCOPED_SAFETY_DISCIPLINES,
   UNIVERSAL_SAFETY_DISCIPLINES,
@@ -243,7 +244,7 @@ export function markArrivalAnnouncedThisProcess(): void {
 export function getDronePlaybook(): string {
   const arrivalInstruction = arrivalAnnouncedThisProcess
     ? ''
-    : '\n**When this MCP session first starts:** post one `ARRIVAL: <your-label> (<your-role>) online on <hostname>` (run `hostname`). After the post succeeds, the client suppresses this instruction until the MCP process restarts; an explicit `/mcp` reconnect may show it again.\n';
+    : `\n**When this MCP session first starts:** post one \`ARRIVAL: <your-label> (<your-role>) online on ${osHostname()}\`. After the post succeeds, the client suppresses this instruction until the MCP process restarts; an explicit \`/mcp\` reconnect may show it again.\n`;
   return `## How to operate as a Drone
 
 You're a Drone in a Cube. Coordinate with other drones through the activity log.
@@ -261,6 +262,12 @@ You're a Drone in a Cube. Coordinate with other drones through the activity log.
 
 **How coordination works:** the Cube gives primitives, not workflows. Your role's \`detailed_description\` (above) is your playbook — its conventions + signals come from there, not the system. The log is the coordination channel. Different cubes, different conventions.
 
+**Communication discipline for non-human seats:**
+- **Console:** write nothing except harness-required output. Surface something to the operator only when blocked and needing unblocking; do not narrate plans, progress, method, or results.
+- **Log:** a post must change what another seat does. Otherwise, do not write it. Keep posts short: lifecycle signal + SHA and nothing else; defect + location/evidence; correction to your live claim; or a genuine blocking question.
+- **Do not post:** plans, work-in-progress/progress narration, method or reasoning, restatements/agreement/credit, self-examination, framing phrases, or coordination commentary.
+- **Evidence boundary:** state what a verdict did not exercise and any unavailable control in the same short clause. The human seat is excluded so its dispatches can explain constraints without being misapplied.
+
 **Default: act autonomously, coordinate through the log.** Don't wait for user input. Need input → post the question, continue other work, other drones respond. The human supervisor is reachable through your cube's coordinating / human-seat role (the role your cube designates for direction + integration), or the Queen role when the seat is delegated to a drone — one continuous seat. Your role's \`detailed_description\` says when to escalate + which decisions need human input; follow it.
 
 **Operating loop — each wake, in order:**

package/src/remote-client.ts

@@ -474,7 +474,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;