borgmcp 2.2.0 → 2.4.0

package/src/assimilate-cmd.ts

@@ -28,6 +28,11 @@ import {
 import type { BorgCli } from './cubes.js';
 import { inboxPathForDrone } from './cubes.js';
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
+import {
+  formatSeatReattachRefusal,
+  inspectLiveInboxMonitor,
+  type LiveInboxMonitor,
+} from './seat-reattach-guard.js';
 import { resolveLaunchEnv } from './model-presets.js';
 import { unlinkSync } from 'node:fs';
 import {
@@ -89,6 +94,7 @@ export interface AssimilateFlags {
   model?: string;
   server?: string;
   enroll?: boolean;
+  force?: boolean;
 }
 
 export interface AssimilateArgs {
@@ -154,6 +160,8 @@ export interface ActiveCube {
   /** Verified local-server CA identity; absent until a local server is selected. */
   serverTrustIdentity?: string;
   localSessionCredentialRef?: string;
+  /** Durable operation that produced this exact seat binding. */
+  operation?: ServerSessionOperation;
   // gh#899: assimilated role, persisted for connect-time tool-surface scoping
   // (mirrors cubes.ts ActiveCube; optional → backward-compatible).
   roleName?: string;
@@ -202,6 +210,11 @@ export interface AssimilateDeps {
   // The scaffold previously declared them sync; that would silently
   // mis-await in Phase F wiring. Promise<...> matches the real shape.
   getActiveCube: () => Promise<ActiveCube | null>;
+  /** Read-only relaunch guard for the saved seat's inbox monitor. */
+  inspectLiveInboxMonitor?: (
+    inboxPath: string,
+    monitorStateRoot: string,
+  ) => LiveInboxMonitor | null;
   hasPersistedActiveCube: () => Promise<boolean>;
   /** Read the RAW persisted local seat for this worktree WITHOUT hydrating its
    *  keychain credential — used to recover a crash-in-gap PENDING seat when
@@ -848,6 +861,12 @@ export async function runAssimilate(
         : `named-sibling:${args.flags.worktree}`)
       : 'current-worktree',
   };
+  // A selected sibling can be the surviving live seat for this worktree (#63).
+  // `--here` must re-send that seat's durable operation, not reconstruct the
+  // in-place operation and then fail PREPARE forever on the wrong ref.
+  if (existing && args.flags.here && existing.operation) {
+    sessionOperation = existing.operation;
+  }
   let reattachPriorId: string | undefined;
   let remintInvalidPrior = false;
   let savedLocalRole: Role | undefined;
@@ -1083,6 +1102,16 @@ export async function runAssimilate(
     reattachPriorId = existing.droneId;
   }
 
+  if (existing && reattachPriorId !== undefined && !args.flags.force) {
+    const inboxPath = deps.getInboxPath(existing.cubeId, existing.droneId);
+    const stateRoot = monitorStateRootForWorktree(projectRoot);
+    const holder = (deps.inspectLiveInboxMonitor ?? inspectLiveInboxMonitor)(inboxPath, stateRoot);
+    if (holder !== null) {
+      deps.stderr(formatSeatReattachRefusal(holder, 'borg assimilate --here --force'));
+      return 1;
+    }
+  }
+
   // ----- Step 5: Role resolution -----
   let resolvedRole: Role | undefined;
   if (savedLocalRole) {
@@ -1545,14 +1574,23 @@ export async function runAssimilate(
           return 1;
         }
         // missing / replaced / threw / unavailable: the worktree owns NO durable
-        // locator, so make NO convergence claim. Roll back the just-spawned worktree
-        // (preserve ONLY when it owns a durable locator) and point at the offline reset.
+        // locator. The server may already have accepted the seat, while the client
+        // has no protocol operation id or cleanup endpoint with which to prove reuse
+        // or remove it. State the exact local outcome and do not prescribe a retry
+        // that can silently create a duplicate server seat (#35).
+        const bindFailure =
+          bindOutcome === 'missing'
+            ? 'the exact pending seat record went missing locally before it could be bound'
+            : bindOutcome === 'replaced'
+              ? 'the exact pending seat record was replaced locally before it could be bound; the replacement was left untouched'
+              : bindOutcome === 'threw'
+                ? 'the local seat store could not be read or written while preserving the pending seat'
+                : 'this client did not receive a pending-seat preservation handle';
         deps.stderr(
-          `This worktree's secure session on ${auth.apiUrl} did not finish activating, and its ` +
-            'seat state could NOT be preserved to this worktree (it was concurrently reset or ' +
-            'replaced, or the local seat store could not be written). No usable seat remains here. ' +
-            `Run ${resetLocalSeatCommand(auth.apiUrl)} to clear any saved seat, then re-run ` +
-            `${localAssimilateCommand(auth.apiUrl)} to attach against the current state.\n`,
+          `This worktree's secure session on ${auth.apiUrl} did not finish activating: ` +
+            `${bindFailure}. The spawned worktree will be removed. No client-only command can ` +
+            'prove reuse or safely clear the possibly accepted server-side seat; ask the server ' +
+            'operator to inspect that seat before retrying.\n',
         );
         rollbackWorktree();
         return 1;

package/src/assimilate-deps.ts

@@ -17,6 +17,7 @@ import prompts from 'prompts';
 import { readinessProbeEnv } from './readiness-probe.js';
 import { resolveMcpBinaryPath } from './self-path.js';
 import { buildRuntimeMetadataReport } from './runtime-metadata.js';
+import { inspectLiveInboxMonitor } from './seat-reattach-guard.js';
 
 import type { AssimilateDeps } from './assimilate-cmd.js';
 import {
@@ -170,6 +171,7 @@ export function buildDefaultAssimilateDeps(
     },
 
     getActiveCube: () => cubesGetActive(),
+    inspectLiveInboxMonitor,
     hasPersistedActiveCube: () => cubesHasPersistedActive(),
     readPersistedLocalSeat: () => readPersistedLocalSeat(),
     peekServerSessionRecord: async (credentialRef, binding) =>

package/src/claude.ts

@@ -26,6 +26,7 @@ import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget, pruneDeadCodexWakeTargets } from './cubes.js';
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
+import { formatSeatReattachRefusal, inspectLiveInboxMonitor } from './seat-reattach-guard.js';
 import { handleVersionFlag, getPackageVersion } from './version.js';
 import { isHelpFlag, setupHelpText, topLevelHelpText, assimilateHelpText, resetLocalSeatHelpText } from './cli-help.js';
 import { runSpawn } from './spawn.js';
@@ -82,6 +83,7 @@ import { installBorgPlugin } from './opencode-plugin.js';
 import { connectOpenCodeDrone, computeOpenCodePort, createOpenCodeLaunchKickoff, injectInitialKickoff } from './opencode-drone.js';
 import { buildOpenCodeLaunchArgs, defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { runEarlyServerFacade } from './server-facade.js';
+import { runEarlyUpdate } from './update-cmd.js';
 
 export type AssimilateDepsBuilder = typeof buildDefaultAssimilateDeps;
 
@@ -101,6 +103,9 @@ export async function runAssimilateEntry(
 }
 
 async function main() {
+  const updateExitCode = await runEarlyUpdate(process.argv);
+  if (updateExitCode !== null) process.exit(updateExitCode);
+
   const serverExitCode = await runEarlyServerFacade(process.argv);
   if (serverExitCode !== null) process.exit(serverExitCode);
 
@@ -306,6 +311,16 @@ async function main() {
     cli = action.cli;
   }
 
+  if (active && !parsedCli.force) {
+    const inboxPath = inboxPathForDrone(active.cubeId, active.droneId);
+    const stateRoot = monitorStateRootForWorktree(findProjectRoot(process.cwd()));
+    const holder = inspectLiveInboxMonitor(inboxPath, stateRoot);
+    if (holder !== null) {
+      process.stderr.write(formatSeatReattachRefusal(holder, 'borg --force'));
+      process.exit(1);
+    }
+  }
+
   // client#20: inspect only the SELECTED harness after the one-shot launch
   // menu choice. Explicit consent enables a narrow per-process override;
   // Borg never rewrites the user's approval policy here.

package/src/cli-help.ts

@@ -27,6 +27,7 @@ export function topLevelHelpText(version: string): string {
     `Usage:\n` +
     `  borg                     Launch your agent CLI; in a TTY, bare borg may show the launch menu\n` +
     `  borg setup               Set up borg MCP server + agent CLI integration\n` +
+    `  borg update              Update the client and installed local server together\n` +
     `  borg assimilate [role]   Join or create a cube\n` +
     `  borg assimilate --host <host>   Join or create on an explicit server\n` +
     `  borg assimilate --worktree <name>   Spawn a worktree drone (in ~/.borg/worktrees/<repo>/<name>)\n` +
@@ -44,6 +45,25 @@ export function topLevelHelpText(version: string): string {
   );
 }
 
+/** Help for the whole-product, npm-owned update journey. */
+export function updateHelpText(version: string): string {
+  return (
+    `borg update${version ? ` (borgmcp ${version})` : ''} — update Borg's client and local server together\n\n` +
+    `Usage:\n` +
+    `  borg update             Confirm interactively, then update\n` +
+    `  borg update --yes       Update without prompting (required outside a TTY)\n` +
+    `  borg update --help      Show this help\n\n` +
+    `Before changing anything, Borg reads the exact published client and server manifests,\n` +
+    `requires matching exact borgmcp-shared pins, and verifies canonical npm ownership. The client is\n` +
+    `installed first and the update continues under that new client before the server controller\n` +
+    `and runtime are updated. Alternate registries and unsupported or ambiguous package-manager\n` +
+    `provenance fail closed with manual-update guidance.\n\n` +
+    `If no local server is installed, the server phase is skipped. A failure after the client\n` +
+    `succeeds is reported as partial completion with the safe retry command. Borg never starts a\n` +
+    `stopped server and never restarts agent processes; restart active agent sessions yourself.\n`
+  );
+}
+
 /** Product Design-approved client-owned copy for `borg server --help`. */
 export function serverHelpText(): string {
   return (
@@ -89,12 +109,14 @@ export function assimilateHelpText(version: string): string {
     `  borg assimilate [role] --worktree <name>   Spawn the drone in an isolated git worktree\n` +
     `                                       (~/.borg/worktrees/<repo>/<name>)\n` +
     `  borg assimilate --here               Assimilate in the current worktree (no sibling spawn)\n` +
+    `  borg assimilate --here --force       Reattach despite a still-live inbox monitor\n` +
     `  borg assimilate --host <host>        Join an authorized self-hosted cube\n` +
     `  borg assimilate --host <host> --enroll   Operator-terminal enrollment, then create/join (preview)\n` +
     `  borg assimilate --help               Show this help\n\n` +
     `Flags:\n` +
     `  --worktree <name>          Create + launch the drone in a sibling git worktree\n` +
     `  --here                     Stay in the current worktree (no sibling spawn)\n` +
+    `  --force                    Override a live-seat guard for a wedged monitor\n` +
     `  --cube-name <name>         Repository cube name (otherwise edit the proposed name)\n` +
     `  --host <host>              Borg server host or URL (bare hosts default to HTTPS)\n` +
     `  --enroll                   Prompt for a hidden enrollment invitation in the operator terminal\n` +

package/src/cli-platform.ts

@@ -101,9 +101,10 @@ export function defaultCliChoiceDeps(prompt: (message: string) => Promise<string
 
 const VALID_CLIS: readonly BorgCli[] = ['claude', 'codex', 'opencode'];
 
-export function parseCliFlag(args: string[]): { cli?: BorgCli; rest: string[]; error?: string } {
+export function parseCliFlag(args: string[]): { cli?: BorgCli; force?: boolean; rest: string[]; error?: string } {
   const rest: string[] = [];
   let cli: BorgCli | undefined;
+  let force = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === '--cli') {
@@ -119,9 +120,11 @@ export function parseCliFlag(args: string[]): { cli?: BorgCli; rest: string[]; e
         return { rest, error: `--cli requires one of: ${VALID_CLIS.join(', ')}` };
       }
       cli = value as BorgCli;
+    } else if (arg === '--force') {
+      force = true;
     } else {
       rest.push(arg);
     }
   }
-  return { cli, rest };
+  return { ...(cli ? { cli } : {}), ...(force ? { force: true } : {}), rest };
 }

package/src/console-prefix.ts

@@ -9,9 +9,9 @@
  * insufficient — the Queen reads the active terminal's output stream,
  * not its title bar.
  *
- * This module exports a one-shot initializer that resolves the prefix
- * from the local cube state cache, plus a synchronous getter that
- * call sites use to wrap each console.error.
+ * This module exports a one-shot initializer that seeds the process-local
+ * display identity from the selected seat, plus a synchronous getter that
+ * follows later server confirmations and wraps each console.error.
  *
  * Format (matches the terminal-title.ts middle-dot convention so
  * surfaces stay internally consistent):
@@ -27,8 +27,13 @@
 import { basename } from 'node:path';
 import chalk from 'chalk';
 import { getActiveCube } from './cubes.js';
+import {
+  _resetDisplayIdentityForTests,
+  currentDisplayIdentity,
+  seedDisplayIdentity,
+} from './display-identity.js';
 
-let cachedPrefix: string | null = null;
+let initialized = false;
 
 /** Neutral prefix for a not-yet-assimilated session (gh#818 P1). */
 function unassimilatedPrefix(): string {
@@ -36,34 +41,35 @@ function unassimilatedPrefix(): string {
 }
 
 /**
- * Resolve the drone-self-identification prefix from cube state and
- * cache it for subsequent synchronous reads. Idempotent — calling
- * multiple times returns the same value. Falls back silently to the
- * unassimilated shape on any read error so console emission is never
- * blocked.
+ * Resolve the drone-self-identification prefix from cube state and seed the
+ * shared display source. Idempotent — later calls do not re-read the store,
+ * while the synchronous prefix still follows server-confirmed display changes.
+ * Falls back silently on any read error so console emission is never blocked.
  */
 export async function initConsolePrefix(): Promise<string> {
-  if (cachedPrefix !== null) return cachedPrefix;
+  if (initialized) return droneIdPrefix();
   try {
     const active = await getActiveCube();
     if (active?.droneLabel && active?.name) {
-      cachedPrefix = `[${active.droneLabel} · ${active.name}]`;
-      return cachedPrefix;
+      seedDisplayIdentity(active);
+      initialized = true;
+      return droneIdPrefix();
     }
   } catch {
     // Fall through to unassimilated fallback.
   }
-  cachedPrefix = unassimilatedPrefix();
-  return cachedPrefix;
+  initialized = true;
+  return unassimilatedPrefix();
 }
 
 /**
- * Synchronous prefix getter. Returns the cached value if initialized,
- * otherwise the unassimilated fallback — safe to call before
+ * Synchronous prefix getter. Returns the current process-local display value
+ * if initialized, otherwise the unassimilated fallback — safe to call before
  * initConsolePrefix() resolves.
  */
 export function droneIdPrefix(): string {
-  if (cachedPrefix !== null) return cachedPrefix;
+  const identity = currentDisplayIdentity();
+  if (initialized && identity) return `[${identity.droneLabel} · ${identity.cubeName}]`;
   return unassimilatedPrefix();
 }
 
@@ -95,5 +101,6 @@ export function cerr(...args: any[]): void {
 }
 
 export function _resetCachedPrefixForTests(): void {
-  cachedPrefix = null;
+  initialized = false;
+  _resetDisplayIdentityForTests();
 }

package/src/cubes.ts

@@ -62,6 +62,8 @@ export interface ActiveCube {
   serverTrustIdentity?: string;
   /** Opaque local-session keychain reference; never a bearer. */
   localSessionCredentialRef?: string;
+  /** Durable seat operation that produced this exact local binding. */
+  operation?: SeatOperation;
   // gh#899: the assimilated role, persisted so the connect-time ListTools
   // handler can role-scope the NATIVE tool surface (UX/context only — never an
   // auth boundary). Absent on pre-gh#899 cubes.json entries → the filter
@@ -279,12 +281,26 @@ async function hydrateActiveCube(record: SeatRecord): Promise<ActiveCube | null>
     apiUrl: record.origin,
     serverTrustIdentity: record.trustIdentity,
     localSessionCredentialRef: ref,
+    operation: record.operation,
     ...(record.roleName !== undefined ? { roleName: record.roleName } : {}),
     ...(record.roleClass !== undefined ? { roleClass: record.roleClass } : {}),
     ...(record.isHumanSeat !== undefined ? { isHumanSeat: record.isHumanSeat } : {}),
   };
 }
 
+/**
+ * Token-free lookup used after an offline reset. A surviving seat is only
+ * described as saved local state; the caller must still revalidate it with the
+ * server before launch.
+ */
+export async function findRemainingActiveSeatForWorktree(worktree: string): Promise<{
+  apiUrl: string;
+  operation: SeatOperation;
+} | null> {
+  const record = await getActiveSeatForWorktree(worktree);
+  return record ? { apiUrl: record.origin, operation: record.operation } : null;
+}
+
 /**
  * Legacy binding-only writer. In the collapsed single-store model an ACTIVE seat is
  * created ONLY by the atomic mint→activate+bind path in seats.ts (driven by the

package/src/display-identity.ts

@@ -0,0 +1,130 @@
+import type { ActiveCube } from './cubes.js';
+
+const LAST_CONFIRMED = ' (last confirmed)';
+
+type DisplayField = {
+  value: string | null;
+  uncertain: boolean;
+};
+
+type DisplayState = {
+  seatKey: string;
+  cubeName: DisplayField;
+  droneLabel: DisplayField;
+  roleName: DisplayField;
+};
+
+export type DisplayIdentity = {
+  cubeName: string;
+  droneLabel: string;
+  roleName: string | null;
+};
+
+export type ServerDisplayIdentity = Partial<DisplayIdentity>;
+
+let state: DisplayState | null = null;
+
+function seatKey(active: Pick<ActiveCube, 'cubeId' | 'droneId'>): string {
+  return `${active.cubeId}\0${active.droneId}`;
+}
+
+function initialState(active: ActiveCube): DisplayState {
+  return {
+    seatKey: seatKey(active),
+    cubeName: { value: active.name, uncertain: false },
+    droneLabel: { value: active.droneLabel, uncertain: false },
+    roleName: { value: active.roleName ?? null, uncertain: false },
+  };
+}
+
+function ensureState(active: ActiveCube): DisplayState {
+  const key = seatKey(active);
+  if (state === null || state.seatKey !== key) {
+    state = initialState(active);
+  }
+  return state;
+}
+
+function confirmField(field: DisplayField, value: string | null | undefined): void {
+  if (value === undefined || value === null) return;
+  field.value = value;
+  field.uncertain = false;
+}
+
+function renderField(field: DisplayField): string | null {
+  if (field.value === null) return null;
+  return field.uncertain ? `${field.value}${LAST_CONFIRMED}` : field.value;
+}
+
+/** Seed the invocation-local display source from the exact seat selected by #63. */
+export function seedDisplayIdentity(active: ActiveCube): void {
+  ensureState(active);
+}
+
+/** Apply server-authoritative fields and clear uncertainty only for those fields. */
+export function confirmDisplayIdentity(
+  active: ActiveCube,
+  identity: ServerDisplayIdentity,
+): DisplayIdentity {
+  const current = ensureState(active);
+  confirmField(current.cubeName, identity.cubeName);
+  confirmField(current.droneLabel, identity.droneLabel);
+  confirmField(current.roleName, identity.roleName);
+  return renderDisplayIdentity(active);
+}
+
+/** Mark the current seat identity as last-confirmed after an identity read fails. */
+export function markDisplayIdentityReadFailed(active: ActiveCube): void {
+  const current = ensureState(active);
+  current.cubeName.uncertain = true;
+  current.droneLabel.uncertain = true;
+  if (current.roleName.value !== null) current.roleName.uncertain = true;
+}
+
+export function renderDisplayIdentity(active: ActiveCube): DisplayIdentity {
+  const current = ensureState(active);
+  return {
+    cubeName: renderField(current.cubeName)!,
+    droneLabel: renderField(current.droneLabel)!,
+    roleName: renderField(current.roleName),
+  };
+}
+
+/** Synchronous view for console-prefix after initConsolePrefix seeds the seat. */
+export function currentDisplayIdentity(): DisplayIdentity | null {
+  if (state === null) return null;
+  return {
+    cubeName: renderField(state.cubeName)!,
+    droneLabel: renderField(state.droneLabel)!,
+    roleName: renderField(state.roleName),
+  };
+}
+
+export function identityFromRegen(result: {
+  cube?: { name?: string | null };
+  drone?: { label?: string | null };
+  role?: { name?: string | null };
+}): ServerDisplayIdentity {
+  return {
+    cubeName: result.cube?.name ?? undefined,
+    droneLabel: result.drone?.label ?? undefined,
+    roleName: result.role?.name ?? undefined,
+  };
+}
+
+export function withRenderedRegenIdentity<T extends {
+  cube?: Record<string, unknown>;
+  drone?: Record<string, unknown>;
+  role?: Record<string, unknown>;
+}>(result: T, identity: DisplayIdentity): T {
+  return {
+    ...result,
+    cube: { ...result.cube, name: identity.cubeName },
+    drone: { ...result.drone, label: identity.droneLabel },
+    role: { ...result.role, name: identity.roleName },
+  };
+}
+
+export function _resetDisplayIdentityForTests(): void {
+  state = null;
+}

package/src/docs-sections.ts

@@ -16,6 +16,7 @@ export const DOCS_BASE_URL = "https://github.com/Byte-Ventures/borg-mcp-client";
 
 const README_URL = `${DOCS_BASE_URL}#readme`;
 const LOCAL_SERVER_URL = `${DOCS_BASE_URL}/blob/main/docs/LOCAL_SERVER.md`;
+const SEAT_LIFECYCLE_URL = `${DOCS_BASE_URL}/blob/main/docs/SEAT_LIFECYCLE.md`;
 
 export interface DocsSection {
   /** logical topic key */
@@ -71,6 +72,14 @@ export const DOCS_SECTIONS: DocsSection[] = [
     summary: "Connect a client to a self-hosted server: invitations, assimilate --host --enroll, credentials.",
     keywords: ["enroll", "enrollment", "invitation", "invite", "assimilate", "--host", "credential", "credentials", "owner", "join server"],
   },
+  {
+    slug: "seat-lifecycle",
+    title: "Seat lifecycle and recovery",
+    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"],
+  },
   {
     slug: "self-hosting",
     title: "Self-hosting operations",

package/src/drone-management.ts

@@ -17,6 +17,7 @@ import {
   reassignDrone,
   type LocalManageOperation,
 } from './remote-client.js';
+import { confirmDisplayIdentity } from './display-identity.js';
 
 interface ManagedCube {
   id: string;
@@ -95,6 +96,11 @@ export async function runReassignDroneTool(
 
   let warning = '';
   if (drone.id === active.droneId) {
+    confirmDisplayIdentity(active, {
+      cubeName: cube.name,
+      droneLabel: drone.label,
+      roleName: role.name,
+    });
     try {
       const refreshed = await deps.refreshActiveCubeMetadata(activeCubeWithFreshRegenIdentity(active, {
         cube,

package/src/inbox-monitor.ts

@@ -753,6 +753,23 @@ export function parseMonitorInvocation(argv: string[]): MonitorInvocation | null
   return null;
 }
 
+function liveMonitorYieldLine(
+  inboxPath: string,
+  holderPidfilePath: string,
+  deps: Pick<InboxLockDeps, 'read' | 'isAlive'>
+): string {
+  const raw = deps.read(holderPidfilePath);
+  const parsed = raw === null ? null : parsePidfileContent(raw.trim());
+  const livePid = parsed && Number.isSafeInteger(parsed.pid) && parsed.pid > 0 && deps.isAlive(parsed.pid)
+    ? parsed.pid
+    : 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.'
+  );
+}
+
 function main(): void {
   const invocation = parseMonitorInvocation(process.argv.slice(2));
   if (!invocation) {
@@ -812,6 +829,7 @@ function main(): void {
   if (claimResult === 'legacy-live') {
     // An already-running old monitor still owns the wake path; yield without
     // touching its inbox-adjacent state.
+    console.log(liveMonitorYieldLine(inboxPath, legacyPidfilePathFor(inboxPath), lockDeps));
     process.exit(0);
   }
   if (claimResult === 'legacy-blocked') {
@@ -822,6 +840,7 @@ function main(): void {
     process.exit(1);
   }
   if (claimResult === 'modern-live') {
+    console.log(liveMonitorYieldLine(inboxPath, pidfilePath, lockDeps));
     process.exit(0);
   }