@quantiya/codevibe-antigravity-plugin 2.0.6 → 2.0.7

package/.env.example

@@ -1,7 +1,7 @@
-# Gemini Companion Plugin Configuration
+# CodeVibe Antigravity Companion Plugin Configuration
 # ======================================
 # NOTE: You typically don't need to edit this file manually.
-# Configuration is auto-set after running 'codevibe-gemini login'.
+# Configuration is auto-set after running 'codevibe login'.
 #
 # Copy this file to .env.production or .env.development and fill in values.
 
@@ -19,10 +19,11 @@ COGNITO_USER_POOL_ID=us-east-1_xxxxxxxxx
 COGNITO_CLIENT_ID=xxxxxxxxxxxxxxxxxxxxxxxxxx
 COGNITO_DOMAIN=your-domain.auth.us-east-1.amazoncognito.com
 
-# Gemini Configuration
-GEMINI_COMMAND=gemini
-GEMINI_TIMEOUT=60000
+# Antigravity CLI Configuration
+# Optional absolute path to an executable agy binary. Invalid values fall back
+# to an executable agy found on PATH.
+# AGY_PATH=/absolute/path/to/agy
 
 # Logging Configuration
-LOG_FILE=/tmp/codevibe-gemini-mcp.log
+LOG_FILE=/tmp/codevibe-agy-mcp.log
 LOG_LEVEL=info

package/README.md

@@ -2,7 +2,7 @@
 
 **Control Google Antigravity CLI from your iPhone and Android.** See your agent's work, approve file edits, dictate prompts by voice — all from your phone, anywhere you are.
 
-🌐 **[quantiya.ai/codevibe](https://quantiya.ai/codevibe)** — landing page, demo video, and one-liner installer
+🌐 **[quantiya.ai/codevibe](https://quantiya.ai/codevibe)** — landing page, demo video, and stable 1.x installer
 
 📱 **[Download on the App Store](https://apps.apple.com/app/id6756500217)** · **[Get it on Google Play](https://play.google.com/store/apps/details?id=ai.quantiya.app.codevibe)**
 
@@ -19,38 +19,35 @@
 - **🔔 Push notifications** — get notified when your agent needs input
 - **🔒 End-to-end encrypted** — AES-256-GCM with ECDH key exchange
 - **🔓 Locked screen support** — works even when your computer screen is locked (via tmux)
-- **🧠 Multi-agent ready** — Antigravity sessions appear alongside Claude, Gemini, and Codex sessions in the same app
+- **🧠 Multi-agent ready** — Antigravity sessions appear alongside Claude and Codex sessions in the same app
 
-## Install in 30 seconds
+## Install the 2.x candidate
 
 ```bash
-curl -fsSL https://quantiya.ai/codevibe/install.sh | bash
-```
-
-Download the **[iOS app](https://apps.apple.com/app/id6756500217)** or **[Android app](https://play.google.com/store/apps/details?id=ai.quantiya.app.codevibe)**, sign in with the same Apple or Google account, and run:
-
-```bash
-codevibe-agy
+npm install -g @quantiya/codevibe@next
+codevibe login
+codevibe --agent agy
 ```
 
-Your session appears on your phone automatically.
+Install Node.js 22+, tmux, and Antigravity CLI first. Then download the **[iOS app](https://apps.apple.com/app/id6756500217)** or **[Android app](https://play.google.com/store/apps/details?id=ai.quantiya.app.codevibe)** and sign in with the same Apple or Google account. Your session appears on your phone automatically.
 
-### Manual install
+### Stable 1.x installer
 
 ```bash
-npm install -g @quantiya/codevibe
-codevibe login
-codevibe-agy
+curl -fsSL https://quantiya.ai/codevibe/install.sh | bash
 ```
 
+The hosted installer remains on stable 1.x while 2.x is validated. It does not
+install the unified `codevibe --agent` interface yet.
+
 ## Requirements
 
 - **macOS, Linux, or WSL Ubuntu** — Windows without WSL is not supported
-- **Node.js** 18.0.0+
+- **Node.js** 22.0.0+
 - **tmux** — `brew install tmux` on macOS, `apt install tmux` on Linux/WSL
 - **Antigravity CLI (`agy`)** — install from [Google's documentation](https://antigravity.google/docs)
 
-> Antigravity CLI is distributed by Google as a binary; it is not on npm. After installing `agy`, run `codevibe-agy` and the plugin handles the rest.
+> Antigravity CLI is distributed by Google as a binary; it is not on npm. After installing `agy`, run `codevibe --agent agy` and the plugin handles the rest.
 
 ## How it works
 
@@ -70,10 +67,10 @@ A single launch session covers the entire wrapper lifetime, so `/resume` command
 ## CLI commands
 
 ```bash
-codevibe-agy              # Start agy with mobile sync
-codevibe-agy login        # Authenticate via browser OAuth
-codevibe-agy status       # Check auth status
-codevibe-agy logout       # Sign out
+codevibe --agent agy      # Start agy with mobile sync
+codevibe login            # Authenticate via browser OAuth
+codevibe status           # Check auth status
+codevibe logout           # Sign out
 ```
 
 ## Troubleshooting
@@ -104,7 +101,6 @@ codevibe update
 - **[@quantiya/codevibe](https://www.npmjs.com/package/@quantiya/codevibe)** — meta-package (install this, not this plugin directly)
 - **[@quantiya/codevibe-core](https://www.npmjs.com/package/@quantiya/codevibe-core)** — shared library used by all plugins
 - **[@quantiya/codevibe-claude-plugin](https://www.npmjs.com/package/@quantiya/codevibe-claude-plugin)** — Claude Code support
-- **[@quantiya/codevibe-gemini-plugin](https://www.npmjs.com/package/@quantiya/codevibe-gemini-plugin)** — Gemini CLI support
 - **[@quantiya/codevibe-codex-plugin](https://www.npmjs.com/package/@quantiya/codevibe-codex-plugin)** — Codex CLI support
 
 ## License

package/dist/server.js

@@ -378,7 +378,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     this.watcher.on("unlink", (filePath) => this.onFileUnlinked(filePath));
     this.watcher.on("error", (error) => {
       logger.error("Chokidar error", { error });
-      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      this.emitError(error);
     });
     this.watcher.on("ready", () => {
       logger.info("Transcript tailer ready (chokidar initial scan complete)");
@@ -388,6 +388,26 @@ var TranscriptTailer = class extends import_events.EventEmitter {
     if (this.flushTimer.unref) this.flushTimer.unref();
     this.isWatching = true;
   }
+  /**
+   * (#638 G4) SAFE 'error' emission. `EventEmitter.emit('error', …)` with NO
+   * registered listener THROWS synchronously — inside a chokidar callback that
+   * becomes an uncaughtException, and inside the async read chain it becomes a
+   * rejection; either way the F6 symmetric process guard can classify it fatal
+   * and kill the daemon over a non-fatal tailing fault (over-death). The server
+   * attaches an 'error' listener before start() (primary path); this guard
+   * covers the residual windows — the doStop teardown detaches listeners
+   * BEFORE the tailer stops, and any embedder that never attached one.
+   */
+  emitError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    if (this.listenerCount("error") > 0) {
+      this.emit("error", err);
+    } else {
+      logger.error("Transcript tailer error (no listener attached \u2014 logged, non-fatal)", {
+        error: String(err)
+      });
+    }
+  }
   /**
    * Stop watching. Flushes offsets one last time before closing chokidar.
    * Idempotent.
@@ -594,7 +614,13 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       return inflight;
     }
     const generation = this.readGeneration;
-    const read = this.drainReadQueue(filePath, conversationId, generation);
+    const read = this.drainReadQueue(filePath, conversationId, generation).catch((error) => {
+      logger.error("Transcript read chain failed (non-fatal) \u2014 next change event retries", {
+        filePath,
+        conversationId,
+        error: String(error)
+      });
+    });
     this.activeReads.set(filePath, read);
     void read.finally(() => {
       if (this.activeReads.get(filePath) === read) {
@@ -651,7 +677,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       });
     } catch (error) {
       logger.error("createReadStream failed", { filePath, error });
-      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      this.emitError(error);
       return;
     }
     let buffered = entry.carryover;
@@ -684,7 +710,7 @@ var TranscriptTailer = class extends import_events.EventEmitter {
       }
     } catch (error) {
       logger.error("Error reading transcript stream", { filePath, error });
-      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      this.emitError(error);
       return;
     }
     if (generation !== this.readGeneration) return;
@@ -2813,6 +2839,16 @@ var McpServer = class {
      *  collapses v8's per-conv disabledConversations Set because there's
      *  only ONE backend session per wrapper. */
     this.sessionDisabled = false;
+    /** (#638 G2) Terminal fail-closed-by-absence marker: createLaunchSession hit
+     *  ENCRYPTED_SESSION_NO_KEY for this identity. Retrying cannot derive a key
+     *  this device does not have, so ensureLaunchSession must NOT re-bootstrap —
+     *  the no-session/no-plaintext outcome is the correct terminal state. Logged
+     *  once at the catch; reset on doStop() alongside sessionDisabled. */
+    this.launchKeyUnavailable = false;
+    /** (#638 G2) Single-flight guard for ensureLaunchSession(): concurrent
+     *  activity-triggered re-bootstraps share ONE createLaunchSession attempt
+     *  instead of double-creating backend rows. Null when no attempt in flight. */
+    this.ensureLaunchInFlight = null;
     /** Registry of agy conv UUIDs the wrapper has observed this lifecycle.
      *  Populated from handleConversationDiscovered + handleTranscriptEmit
      *  (after isMainConversation passes). Used by:
@@ -2850,6 +2886,15 @@ var McpServer = class {
      *  out mid-cleanup — separating the bounded "wait for create" from the
      *  always-awaited "mark INACTIVE". (#142 Stage 2 R1 iter-2 HIGH.) */
     this.pendingLaunchSessionId = null;
+    /** (#638 H4) Set by doStop() when a stop runs while a createLaunchSession may
+     *  still be in flight (the bounded Phase-0 settle can expire mid-create). The
+     *  create's post-await tail includes this in its bail check, so a create that
+     *  resolves AFTER doStop's settle bound still deactivates its just-created row
+     *  itself — the settlement obligation survives until the create CONCLUSIVELY
+     *  finishes, instead of doStop "completing" it with a missing-row INACTIVE
+     *  write the backend rejected. Reset on the next start() (a stale prior-
+     *  lifecycle create is additionally caught by the gen mismatch). */
+    this.stopRequestedDuringCreate = false;
     /** Listener references kept so doStop() can detach them. Without this,
      *  a server restart (test mode or future hot-reload) accumulates
      *  listeners on the shared module instances. (Stage 2 HIGH finding
@@ -2907,11 +2952,12 @@ var McpServer = class {
         error_message: "no stored OAuth tokens"
       });
       throw new Error(
-        "codevibe-antigravity-plugin: no OAuth tokens \u2014 run `codevibe-agy login` first"
+        "codevibe-antigravity-plugin: no OAuth tokens \u2014 run `codevibe login` first"
       );
     }
     this.started = true;
     this.lifecycleGen++;
+    this.stopRequestedDuringCreate = false;
     this.registerSignalHandlers();
     await (0, import_codevibe_core4.registerDeviceEncryptionKey)(this.appSyncClient, logger);
     if (!this.started) return { httpPort: 0 };
@@ -2946,6 +2992,9 @@ var McpServer = class {
     if (!this.started) {
       return { httpPort: 0 };
     }
+    this.addListener(this.transcriptTailer, "error", (err) => {
+      logger.error("transcript tailer error (non-fatal)", { error: String(err) });
+    });
     this.addListener(this.transcriptTailer, "event", (emit) => {
       void this.handleTranscriptEmit(emit).catch((err) => {
         logger.error("handleTranscriptEmit failed", { error: String(err) });
@@ -3008,8 +3057,16 @@ var McpServer = class {
     }
     if (this.pendingLaunchSessionId) {
       const pendingId = this.pendingLaunchSessionId;
-      this.pendingLaunchSessionId = null;
-      await this.deactivateLaunchRow(pendingId);
+      this.stopRequestedDuringCreate = true;
+      const deactivated = await this.deactivateLaunchRow(pendingId);
+      if (deactivated) {
+        if (this.pendingLaunchSessionId === pendingId) this.pendingLaunchSessionId = null;
+      } else {
+        logger.error(
+          "doStop: INACTIVE write for the pending launch row FAILED (row may not exist yet \u2014 create still in flight). Keeping the settlement obligation: if the create resolves in-process its tail deactivates the row; if the process exits first, an ACTIVE row may leak (SIGKILL-class residual) (#638 H4)",
+          { sessionId: pendingId }
+        );
+      }
     }
     if (this.subscription) {
       try {
@@ -3070,6 +3127,8 @@ var McpServer = class {
     }
     this.session = null;
     this.sessionDisabled = false;
+    this.launchKeyUnavailable = false;
+    this.ensureLaunchInFlight = null;
     this.observedMainConversationIds.clear();
     await fireDaemonBeacon("daemon_init_step", {
       step: "shutdown",
@@ -3079,6 +3138,7 @@ var McpServer = class {
   async handleConversationDiscovered(conversationId) {
     if (!this.started) return;
     if (this.sessionDisabled) return;
+    await this.ensureLaunchSession();
     if (!this.session) return;
     if (!this.isMainConversation(conversationId)) {
       logger.debug("Ignoring discovery for non-main conversation (subagent)", { conversationId });
@@ -3098,17 +3158,25 @@ var McpServer = class {
    * can't clobber or resurrect ACTIVE. (Separate from the ACTIVE-vs-INACTIVE
    * per-session ordering that core 1.0.29's status-write chain handles.)
    * (#142 Stage 2 R1 iter-2.)
+   *
+   * (#638 H4) Returns whether the INACTIVE write actually SUCCEEDED. A swallowed
+   * failure here is NOT a settled obligation — the row may not exist yet (a
+   * create still in flight) or the network may be down — so callers must keep
+   * their settlement marker/obligation alive on `false` instead of treating the
+   * attempt as completion. The log stays inside so no failure is ever silent.
    */
   async deactivateLaunchRow(sessionId) {
     try {
       this.appSyncClient.stopHeartbeat(sessionId);
       await this.appSyncClient.updateSession({ sessionId, status: "INACTIVE" });
       logger.info("Marked superseded/interrupted launch session INACTIVE", { sessionId });
+      return true;
     } catch (err) {
       logger.warn("Failed to mark superseded/interrupted launch session INACTIVE", {
         sessionId,
         error: String(err)
       });
+      return false;
     }
   }
   /**
@@ -3143,7 +3211,7 @@ var McpServer = class {
       );
       sessionKey = result.sessionKey ?? null;
     } catch (err) {
-      this.pendingLaunchSessionId = null;
+      if (this.pendingLaunchSessionId === sessionId) this.pendingLaunchSessionId = null;
       const msg = String(err);
       if (msg.includes("session-limit-exceeded")) {
         logger.warn("Free-tier session limit reached \u2014 mobile sync disabled for this wrapper", { sessionId });
@@ -3151,12 +3219,25 @@ var McpServer = class {
         this.sessionDisabled = true;
         return;
       }
-      logger.error("createLaunchSession failed (non-fatal)", { sessionId, error: msg });
+      if (err?.code === "ENCRYPTED_SESSION_NO_KEY") {
+        logger.error("createLaunchSession: ENCRYPTED_SESSION_NO_KEY \u2014 no key for the encrypted session; no session created, mobile sync fails closed (no plaintext) (#638)", { sessionId });
+        if (gen !== this.lifecycleGen || !this.started) return;
+        this.launchKeyUnavailable = true;
+        return;
+      }
+      logger.error("createLaunchSession failed (non-fatal; next activity re-attempts via ensureLaunchSession \u2014 #638 G2)", { sessionId, error: msg });
       return;
     }
-    if (gen !== this.lifecycleGen || !this.started) {
-      await this.deactivateLaunchRow(sessionId);
-      if (this.pendingLaunchSessionId === sessionId) this.pendingLaunchSessionId = null;
+    if (gen !== this.lifecycleGen || !this.started || this.stopRequestedDuringCreate) {
+      const deactivated = await this.deactivateLaunchRow(sessionId);
+      if (deactivated) {
+        if (this.pendingLaunchSessionId === sessionId) this.pendingLaunchSessionId = null;
+      } else {
+        logger.error(
+          "createLaunchSession bail: INACTIVE write for the just-created row FAILED \u2014 settlement obligation remains open (marker kept); the row may leak ACTIVE if nothing retries before exit (#638 H4)",
+          { sessionId }
+        );
+      }
       return;
     }
     this.session = {
@@ -3169,7 +3250,14 @@ var McpServer = class {
       createdAt: /* @__PURE__ */ new Date(),
       subscriptionActive: false,
       metadata: { wrapperPid: this.wrapperPid ?? void 0, launch: true },
-      sessionKey
+      sessionKey,
+      // (#638) A null key here means a genuinely unencrypted/legacy session
+      // (resumeOrCreateSession THROWS ENCRYPTED_SESSION_NO_KEY for an encrypted
+      // session this device can't key, handled in the catch above — no session
+      // is created there). So `!!sessionKey` correctly classifies this row; if a
+      // later path ever nulls the key on an encrypted session, encryptOutbound
+      // fails closed instead of leaking plaintext.
+      sessionIsEncrypted: !!sessionKey
     };
     this.pendingLaunchSessionId = null;
     try {
@@ -3206,6 +3294,43 @@ var McpServer = class {
     });
     logger.info("Launch session created", { sessionId, userId });
   }
+  /**
+   * (#638 G2) Single-flight re-bootstrap of the launch session on first
+   * subsequent activity. createLaunchSession() runs once from start(); before
+   * this fix a transient failure there (slow/absent network at daemon start —
+   * the incident) left `this.session = null` forever: every emit site guards
+   * `if (!this.session) return` with no re-bootstrap trigger, so the daemon
+   * lived but never synced (permanently headless).
+   *
+   * Called from the emit-relevant entry points (transcript event handling /
+   * prompt handling / mobile-event handling) BEFORE their `!this.session`
+   * guards. Semantics preserved:
+   *  - session present → returns immediately (fast path, no work);
+   *  - session-limit-exceeded → sessionDisabled stays TERMINAL (no retry);
+   *  - ENCRYPTED_SESSION_NO_KEY → launchKeyUnavailable stays TERMINAL for this
+   *    identity (fail-closed by absence, logged once);
+   *  - ONLY generic/transient errors are retried, single-flight per activity
+   *    arrival (inherently rate-bounded — one attempt per incoming event, and
+   *    concurrent arrivals share one attempt);
+   *  - lifecycleGen/started guards are honored by createLaunchSession itself
+   *    (gen captured at entry, rechecked after every await).
+   */
+  async ensureLaunchSession() {
+    if (this.session) return;
+    if (!this.started || this.sessionDisabled || this.launchKeyUnavailable) return;
+    if (this.ensureLaunchInFlight) {
+      await this.ensureLaunchInFlight;
+      return;
+    }
+    const attempt = this.createLaunchSession();
+    this.ensureLaunchInFlight = attempt;
+    this.launchSessionPromise = attempt;
+    try {
+      await attempt;
+    } finally {
+      if (this.ensureLaunchInFlight === attempt) this.ensureLaunchInFlight = null;
+    }
+  }
   isMainConversation(conversationId) {
     if (process.env.JEST_WORKER_ID && !this.cliLogPath) {
       return true;
@@ -3224,6 +3349,7 @@ var McpServer = class {
     if (this.sessionDisabled) {
       return;
     }
+    await this.ensureLaunchSession();
     if (!this.session) {
       return;
     }
@@ -3271,7 +3397,9 @@ var McpServer = class {
         }
       }
       try {
-        await this.appSyncClient.createEvent(this.encryptOutbound(session, input));
+        const outbound = this.encryptOutbound(session, input);
+        if (!outbound) continue;
+        await this.appSyncClient.createEvent(outbound);
       } catch (err) {
         logger.error("createEvent failed", {
           sessionId: session.sessionId,
@@ -3282,37 +3410,39 @@ var McpServer = class {
     }
   }
   /**
-   * If the session has an E2E sessionKey, encrypt the event's content +
-   * metadata and stamp isEncrypted=true. Returns a new CreateEventInput;
-   * never mutates the input. When no key is set, returns input unchanged.
-   * (Codex Stage 2 HIGH finding 2026-05-20.)
+   * (#638) THE single encrypt-or-fail-closed decision for EVERY mobile-visible
+   * emit, delegated to @quantiya/codevibe-core's encryptForEmit so all three
+   * companion agents share ONE chokepoint. Returns a new CreateEventInput
+   * (never mutates the input), or NULL when the session IS encrypted but has no
+   * derivable key — the caller MUST DROP the event (fail-closed). Previously
+   * this method returned `input` unchanged for ANY keyless session, leaking
+   * cleartext for an encrypted-but-keyless session; the `sessionIsEncrypted`
+   * flag now distinguishes a genuinely unencrypted session (plaintext OK) from
+   * an encrypted keyless one (drop).
    */
   encryptOutbound(session, input) {
-    if (!session.sessionKey) return input;
-    try {
-      const encryptedContent = import_codevibe_core4.cryptoService.encryptContent(input.content, session.sessionKey);
-      let encryptedMetadata = input.metadata;
-      if (input.metadata) {
-        const encryptedMetaStr = import_codevibe_core4.cryptoService.encryptMetadata(
-          input.metadata,
-          session.sessionKey
-        );
-        encryptedMetadata = { encrypted: encryptedMetaStr };
-      }
-      return {
-        ...input,
-        content: encryptedContent,
-        metadata: encryptedMetadata,
-        isEncrypted: true
-      };
-    } catch (err) {
-      logger.error("Outbound encryption failed \u2014 DROPPING event to avoid plaintext leak", {
+    const enc = (0, import_codevibe_core4.encryptForEmit)(
+      session.sessionKey ?? null,
+      session.sessionIsEncrypted ?? false,
+      input.content,
+      input.metadata
+    );
+    if (enc === null) {
+      logger.error("No session key for ENCRYPTED session \u2014 DROPPING event to avoid plaintext leak (#638)", {
         sessionId: session.sessionId,
-        type: input.type,
-        error: String(err)
+        type: input.type
       });
-      throw err;
+      return null;
+    }
+    if (!enc.isEncrypted) {
+      return input;
     }
+    return {
+      ...input,
+      content: enc.content,
+      metadata: enc.metadata,
+      isEncrypted: true
+    };
   }
   /**
    * If the inbound mobile event is marked isEncrypted, decrypt content +
@@ -3357,6 +3487,7 @@ var McpServer = class {
   async handlePromptCandidate(cand) {
     if (!this.started) return;
     if (this.sessionDisabled) return;
+    await this.ensureLaunchSession();
     if (!this.session) return;
     const parsed = parseApprovalSnapshot(cand.snapshot);
     if (!parsed) return;
@@ -3446,7 +3577,9 @@ var McpServer = class {
       })
     };
     try {
-      await this.appSyncClient.createEvent(this.encryptOutbound(session, input));
+      const outbound = this.encryptOutbound(session, input);
+      if (!outbound) return;
+      await this.appSyncClient.createEvent(outbound);
     } catch (err) {
       logger.error("createEvent INTERACTIVE_PROMPT failed", {
         promptId: state.promptId,
@@ -3542,6 +3675,7 @@ var McpServer = class {
   async handleMobileEvent(evt) {
     if (!this.started) return;
     if (this.sessionDisabled) return;
+    await this.ensureLaunchSession();
     if (!this.session) return;
     const session = this.session;
     if (evt.source !== import_codevibe_core4.EventSource.MOBILE) return;
@@ -3705,6 +3839,11 @@ var McpServer = class {
       timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: payload.sessionId })
     };
     const finalInput = this.encryptOutbound(session, input);
+    if (!finalInput) {
+      throw new Error(
+        `fail-closed: encrypted session ${payload.sessionId} has no session key \u2014 event dropped (#638)`
+      );
+    }
     const created = await this.appSyncClient.createEvent(finalInput);
     return { eventId: created.eventId };
   }
@@ -3846,6 +3985,11 @@ async function main() {
     tmuxTarget: process.env.CODEVIBE_AGY_TMUX_TARGET ?? void 0,
     wrapperPid: process.env.CODEVIBE_AGY_WRAPPER_PID ? parseInt(process.env.CODEVIBE_AGY_WRAPPER_PID, 10) : void 0
   });
+  (0, import_codevibe_core4.installDaemonProcessGuards)(logger, {
+    onFatal: () => {
+      void server.stop().finally(() => process.exit(1));
+    }
+  });
   try {
     const { httpPort } = await server.start();
     logger.info("codevibe-antigravity-plugin ready", { httpPort });

package/{bin/codevibe-agy → libexec/companion-launcher}

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# codevibe-agy — wrapper that runs Antigravity CLI (agy) inside a tmux
+# Private CodeVibe Companion launcher for Antigravity CLI (agy), using a tmux
 # session bridged to the CodeVibe MCP server for mobile sync.
 #
 # Architecture (DESIGN.md §3 + §5.2):
@@ -34,19 +34,15 @@
 #      server's signal handler), kill MCP server, remove runtime dir.
 #
 # Usage:
-#   codevibe-agy [agy-args...]         # Start agy session
-#   codevibe-agy login                 # Sign in via browser
-#   codevibe-agy logout                # Sign out
-#   codevibe-agy status                # Show auth status
-#   codevibe-agy reset-device          # Reset device key (re-pair)
+#   codevibe --agent agy [-- agy-args...]
 #
 # Environment:
 #   ENVIRONMENT                    Set to 'production' (default) or 'development'
 #   AGY_PATH                       Path to agy binary (default: $(command -v agy))
 #
-# v1.0 limitations:
+# Companion limitations:
 #   - Requires tmux. Print mode (`--print` / `-p`) is NOT supported.
-#   - Requires Node.js ≥ 18 for the MCP server.
+#   - Requires Node.js 22 or newer for the MCP server.
 #
 
 set -e
@@ -62,14 +58,6 @@ case "${ENVIRONMENT:-}" in
 esac
 CODEVIBE_TMPDIR="${TMPDIR:-/tmp}"
 
-# ─── Config dir (agent-detection marker) ──────────────────────────────
-# Ensure ~/.codevibe-antigravity exists on EVERY invocation (including the
-# fast `--version` path and normal sessions). The CodeVibe 2.0 companion
-# agent-detection probe marks agy "healthy" only when this dir exists
-# (matching the claude/codex convention where the config dir signals
-# "set up"). Non-fatal — a mkdir failure must never break the wrapper.
-mkdir -p "$HOME/.codevibe-antigravity" 2>/dev/null || true
-
 # Resolve plugin dir via symlink-aware traversal (npm globals symlink
 # bin/ into /usr/local/bin/).
 SOURCE="${BASH_SOURCE[0]}"
@@ -84,8 +72,8 @@ PLUGIN_DIR="$(dirname "$SCRIPT_DIR")"
 # ─── PATH augmentation ───────────────────────────────────────────────
 # When the install one-liner runs in a fresh terminal, Homebrew's
 # installer writes the shellenv eval into ~/.zprofile (etc.) but the
-# user's current shell hasn't sourced it yet. Subsequent codevibe-*
-# runs in that same terminal then fail tmux/node/agy discovery because
+# user's current shell hasn't sourced it yet. CodeVibe Companion launches
+# in that terminal then fail tmux/node/agy discovery because
 # /opt/homebrew/bin isn't on PATH. Prepend common locations so the
 # wrapper recovers without forcing a new terminal.
 _CV_NEW_PATHS=""
@@ -145,38 +133,45 @@ cv_failed() {
   cv_telem "wrapper_failed" "\"reason\":\"$1\",\"lifetime_seconds\":$(( $(date +%s) - _CV_STARTED_AT ))"
 }
 
-# ─── Auth + version commands: short-circuit BEFORE any heavy boot ──────
-case "$1" in
-    version|--version|-v)
-        # Fast, guaranteed-non-fatal version probe. Must NOT boot the MCP
-        # server, run the tmux pre-flight, or spawn anything heavy — the
-        # CodeVibe 2.0 companion agent-detection probe runs `codevibe-agy
-        # --version` and only requires exit 0. Print the plugin version;
-        # also surface the underlying `agy` version when it's on PATH.
-        _CV_VER="$(node -p "require('$PLUGIN_DIR/package.json').version" 2>/dev/null || echo unknown)"
-        echo "codevibe-agy $_CV_VER"
-        _CV_AGY_BIN="${AGY_PATH:-$(command -v agy 2>/dev/null || true)}"
-        if [ -n "$_CV_AGY_BIN" ] && [ -x "$_CV_AGY_BIN" ]; then
-            _CV_AGY_RAW="$("$_CV_AGY_BIN" --version 2>/dev/null | head -1)"
-            [ -n "$_CV_AGY_RAW" ] && echo "agy $_CV_AGY_RAW"
-        fi
-        exit 0
-        ;;
-    login|logout|status|reset-device)
-        CORE_CLI="$PLUGIN_DIR/node_modules/@quantiya/codevibe-core/bin/codevibe.js"
-        # Also check hoisted location (when installed via @quantiya/codevibe meta-package).
-        if [ ! -f "$CORE_CLI" ]; then
-            CORE_CLI="$PLUGIN_DIR/../codevibe-core/bin/codevibe.js"
-        fi
-        if [ -f "$CORE_CLI" ]; then
-            cv_telem "wrapper_started" "\"invocation\":\"auth_$1\",\"os\":\"$(uname -s | cv_sanitize)\",\"arch\":\"$(uname -m | cv_sanitize)\""
-            exec node "$CORE_CLI" "$1"
-        else
-            echo "Error: codevibe-core not found. Try reinstalling: npm install -g @quantiya/codevibe"
-            cv_failed "core_not_found"
-            sleep 1
-            exit 1
+# AGY_PATH is an optional preferred executable, not a poison pill. If it is
+# unset or invalid, fall back to the same PATH lookup used by agent discovery.
+# Requiring a regular executable file keeps this contract aligned with
+# codevibe-core's isExecutableFile() check.
+resolve_agy_bin() {
+    if [ -n "${AGY_PATH:-}" ] && [ -f "$AGY_PATH" ] && [ -x "$AGY_PATH" ]; then
+        printf '%s\n' "$AGY_PATH"
+        return 0
+    fi
+    command -v agy 2>/dev/null || true
+}
+
+# ─── Internal diagnostic: short-circuit before heavy boot ─────────────
+# Keep this off the public argv surface so `codevibe --agent agy -- --version`
+# reaches the vendor CLI unchanged.
+if [ "${CODEVIBE_COMPANION_DIAGNOSTIC:-}" = "version" ]; then
+    _CV_VER="$(node -p "require('$PLUGIN_DIR/package.json').version" 2>/dev/null || echo unknown)"
+    echo "codevibe companion agy $_CV_VER"
+    _CV_AGY_BIN="$(resolve_agy_bin)"
+    if [ -n "$_CV_AGY_BIN" ] && [ -f "$_CV_AGY_BIN" ] && [ -x "$_CV_AGY_BIN" ]; then
+        _CV_AGY_RAW="$("$_CV_AGY_BIN" --version 2>/dev/null | head -1)"
+        [ -n "$_CV_AGY_RAW" ] && echo "agy $_CV_AGY_RAW"
+    fi
+    exit 0
+fi
+
+# Metadata commands are intentionally short-lived and do not create a
+# Companion session. Run them directly in the foreground so a TTY invocation
+# cannot race a detached tmux session that exits before attach. Arguments and
+# the vendor exit status are preserved exactly.
+case "${1:-}" in
+    --version|-v|--help|-h)
+        _CV_DIRECT_AGY_BIN="$(resolve_agy_bin)"
+        if [ -z "$_CV_DIRECT_AGY_BIN" ] || ! [ -f "$_CV_DIRECT_AGY_BIN" ] || ! [ -x "$_CV_DIRECT_AGY_BIN" ]; then
+            echo "Error: Antigravity CLI (`agy`) is not installed or not executable." >&2
+            echo "Install instructions: https://antigravity.google/docs" >&2
+            exit 127
         fi
+        exec "$_CV_DIRECT_AGY_BIN" "$@"
         ;;
 esac
 
@@ -187,7 +182,7 @@ command -v node >/dev/null 2>&1 && _CV_NODE_VER="$(node -v 2>/dev/null | cv_sani
 _CV_TMUX_VER="missing"
 command -v tmux >/dev/null 2>&1 && _CV_TMUX_VER="$(tmux -V 2>/dev/null | cv_sanitize)"
 [ -z "$_CV_TMUX_VER" ] && _CV_TMUX_VER="unknown"
-_CV_AGY_BIN="${AGY_PATH:-$(command -v agy 2>/dev/null || true)}"
+_CV_AGY_BIN="$(resolve_agy_bin)"
 _CV_AGY_VER="missing"
 [ -n "$_CV_AGY_BIN" ] && _CV_AGY_VER="$("$_CV_AGY_BIN" --version 2>/dev/null | cv_sanitize)"
 [ -z "$_CV_AGY_VER" ] && _CV_AGY_VER="unknown"
@@ -213,7 +208,7 @@ log() {
 for arg in "$@"; do
     case "$arg" in
         --print|-p|--prompt|--print=*|--prompt=*|-p=*)
-            echo "Error: codevibe-agy does not support --print / -p / --prompt in v1.0."
+            echo "Error: the Antigravity Companion route does not support --print / -p / --prompt."
             echo "Run \"agy ...\" directly for non-interactive use; mobile sync is interactive-only."
             cv_failed "print_mode_unsupported"
             sleep 1
@@ -231,7 +226,7 @@ if ! command -v tmux &> /dev/null; then
     exit 1
 fi
 
-if [ -z "$_CV_AGY_BIN" ] || ! [ -x "$_CV_AGY_BIN" ]; then
+if [ -z "$_CV_AGY_BIN" ] || ! [ -f "$_CV_AGY_BIN" ] || ! [ -x "$_CV_AGY_BIN" ]; then
     echo "Error: Antigravity CLI (\`agy\`) is not installed or not executable."
     echo "Install instructions: https://antigravity.google/docs"
     cv_failed "agy_missing"
@@ -241,7 +236,7 @@ fi
 
 if ! command -v node &> /dev/null; then
     echo "Error: Node.js is required but not installed."
-    echo "Install Node.js 18+ from: https://nodejs.org"
+    echo "Install Node.js 22+ from: https://nodejs.org"
     cv_failed "node_missing"
     sleep 1
     exit 1
@@ -459,8 +454,8 @@ while [ \$i -lt 100 ] && [ ! -f '$escaped_conn_file' ]; do
   i=\$((i + 1))
 done
 if [ ! -f '$escaped_conn_file' ]; then
-  echo 'codevibe-agy: MCP server not ready after 10s; running agy without mobile sync.' >&2
-  echo 'codevibe-agy: see $escaped_mcp_log for details.' >&2
+  echo 'CodeVibe Antigravity Companion: MCP server not ready after 10s; running agy without mobile sync.' >&2
+  echo 'CodeVibe Antigravity Companion: see $escaped_mcp_log for details.' >&2
 fi
 export ENVIRONMENT='$ENVIRONMENT'
 $AGY_CMD
@@ -517,7 +512,7 @@ if ! kill -0 "$MCP_PID" 2>/dev/null; then
     tail -3 "$MCP_LOG_FILE" 2>/dev/null | grep -v '^\[' | head -3
     echo ""
     echo "Server failed to start. Check $MCP_LOG_FILE for details."
-    echo "Common causes: not signed in (\`codevibe-agy login\`), port in use, ENV mismatch."
+    echo "Common causes: not signed in (\`codevibe login\`), port in use, ENV mismatch."
     # tmux session is already created — destroy it so the user doesn't
     # attach to a degraded session that will time-out waiting for conn.json.
     tmux kill-session -t "$SESSION_NAME" 2>/dev/null || true

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Control Antigravity CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
-  "bin": {
-    "codevibe-agy": "./bin/codevibe-agy"
+  "codevibe": {
+    "companionLauncher": "./libexec/companion-launcher"
   },
   "files": [
     "dist/**/*.js",
-    "bin",
+    "libexec",
     "antigravity-plugin.json",
     "README.md",
     ".env.example"
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "2.0.6",
+    "@quantiya/codevibe-core": "2.0.7",
     "chokidar": "^5.0.0",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",