@quantiya/codevibe-antigravity-plugin 2.0.17 → 2.0.19

package/dist/server.js

@@ -46,7 +46,7 @@ var fs5 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 var import_util3 = require("util");
-var import_codevibe_core4 = require("@quantiya/codevibe-core");
+var import_codevibe_core5 = require("@quantiya/codevibe-core");
 
 // src/logger.ts
 var import_os = __toESM(require("os"));
@@ -1961,7 +1961,7 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
     let matchedKey = null;
     for (const [key, call] of this.pendingCalls.entries()) {
       if (call.conversationId !== args.conversationId) continue;
-      if (call.toolType !== args.toolType) continue;
+      if (args.toolType !== "GENERIC" && call.toolType !== args.toolType) continue;
       const expected = call.intentStepIndex + call.toolCallIndex + 1;
       if (expected !== args.resultStepIndex) continue;
       if (typeof args.resultByteOffset === "number") {
@@ -3010,6 +3010,255 @@ function truncate(s, maxBytes) {
   return s.slice(0, lo) + ` [...truncated ${s.length - lo} chars]`;
 }
 
+// src/tool-activity-integration.ts
+var import_codevibe_core4 = require("@quantiya/codevibe-core");
+var TOOL_ACTIVITY_CONTENT = "tool_activity";
+var DEFAULT_WINDOW_MS = 1e4;
+var DEFAULT_MAX_OCCURRENCES = 50;
+var DEFAULT_SHUTDOWN_DRAIN_MS = 3e3;
+function terminalSessionError(sessionId) {
+  return Object.assign(new Error(`Antigravity session is no longer active: ${sessionId}`), {
+    errorType: "SessionTerminal"
+  });
+}
+function friendlyHookToolName(rawName, resultType) {
+  switch (rawName?.toUpperCase()) {
+    case "RUN_COMMAND":
+      return "Bash";
+    case "LIST_DIR":
+      return "LS";
+    case "GREP_SEARCH":
+      return "Grep";
+    case "VIEW_FILE":
+      return "Read";
+    case "WRITE_TO_FILE":
+    case "REPLACE_FILE_CONTENT":
+    case "MULTI_REPLACE_FILE_CONTENT":
+      return "Edit";
+    case "SEARCH_WEB":
+      return "WebSearch";
+    case "READ_URL_CONTENT":
+      return "WebFetch";
+    case "GENERATE_IMAGE":
+      return "ImageGen";
+    case "INVOKE_SUBAGENT":
+    case "DEFINE_SUBAGENT":
+    case "MANAGE_SUBAGENTS":
+      return "Agent";
+    case "SEND_MESSAGE":
+      return "SendMessage";
+    case "LIST_PERMISSIONS":
+      return "Permissions";
+    case "MANAGE_TASK":
+      return "Task";
+    case "SCHEDULE":
+      return "Schedule";
+    case "ASK_PERMISSION":
+    case "ASK_QUESTION":
+      return "AskUserQuestion";
+    default:
+      return transcriptTypeToFriendlyToolName(resultType);
+  }
+}
+function commandTarget(command) {
+  return command?.trim().split(/\s+/)[0] || void 0;
+}
+function agyOccurrenceId(emit, matchedCall) {
+  const identity = matchedCall ? {
+    conversationId: matchedCall.conversationId,
+    intentCreatedAt: matchedCall.intentCreatedAt,
+    intentStepIndex: matchedCall.intentStepIndex,
+    toolCallIndex: matchedCall.toolCallIndex,
+    rawToolName: matchedCall.rawToolName ?? null,
+    command: matchedCall.command ?? null,
+    filePath: matchedCall.filePath ?? null,
+    cwd: matchedCall.cwd ?? null
+  } : {
+    conversationId: emit.conversationId,
+    createdAt: emit.event.created_at,
+    stepIndex: emit.event.step_index,
+    type: emit.event.type,
+    contentDigest: (0, import_codevibe_core4.digestOf)(emit.event.content ?? "")
+  };
+  return `agy:${(0, import_codevibe_core4.digestOf)(identity).slice("sha256:".length)}`;
+}
+var AgyToolActivityIntegration = class {
+  constructor(deps) {
+    this.consolidator = null;
+    this.backendSessionId = null;
+    this.sessionsToRehome = /* @__PURE__ */ new Set();
+    this.deps = deps;
+  }
+  isActive() {
+    return this.consolidator !== null;
+  }
+  async start(sessionId) {
+    if (this.consolidator && this.backendSessionId === sessionId) return;
+    if (this.consolidator) await this.stop();
+    const outbox = new import_codevibe_core4.ToolActivityOutbox({
+      agent: "agy",
+      logger: this.deps.logger,
+      root: this.deps.root
+    });
+    await this.rehomePendingWindows(outbox, sessionId);
+    const ledger = new import_codevibe_core4.ToolActivityLedger({
+      agent: "agy",
+      sessionId,
+      logger: this.deps.logger,
+      root: this.deps.root
+    });
+    const consolidator = new import_codevibe_core4.ToolActivityConsolidator({
+      agent: "agy",
+      sessionId,
+      logger: this.deps.logger,
+      outbox,
+      ledger,
+      transport: this.buildTransport(),
+      windowMs: this.deps.windowMs ?? DEFAULT_WINDOW_MS,
+      maxOccurrences: DEFAULT_MAX_OCCURRENCES
+    });
+    this.backendSessionId = sessionId;
+    try {
+      await consolidator.init();
+      this.consolidator = consolidator;
+      this.deps.logger.info("[tool-activity] Agy consolidator started", { sessionId });
+    } catch (error) {
+      this.backendSessionId = null;
+      await consolidator.shutdown().catch(() => void 0);
+      throw error;
+    }
+  }
+  async observeResult(emit, matchedCall) {
+    const consolidator = this.consolidator;
+    if (!consolidator) return void 0;
+    const resultType = emit.event.type;
+    const target = matchedCall?.filePath ?? commandTarget(matchedCall?.command) ?? matchedCall?.cwd;
+    const inputIdentity = matchedCall ? {
+      rawToolName: matchedCall.rawToolName ?? null,
+      command: matchedCall.command ?? null,
+      filePath: matchedCall.filePath ?? null,
+      cwd: matchedCall.cwd ?? null
+    } : void 0;
+    return consolidator.observe({
+      id: agyOccurrenceId(emit, matchedCall),
+      tool: friendlyHookToolName(matchedCall?.rawToolName, resultType),
+      ...target ? { normalizedTarget: target } : {},
+      ts: emit.event.created_at,
+      byteOffset: emit.byteOffset,
+      ...inputIdentity ? { digest: (0, import_codevibe_core4.digestOf)(inputIdentity) } : {}
+    });
+  }
+  async flush() {
+    await this.consolidator?.flush();
+  }
+  async stop() {
+    const consolidator = this.consolidator;
+    this.consolidator = null;
+    if (!consolidator) {
+      this.backendSessionId = null;
+      return;
+    }
+    await consolidator.drainSends(this.deps.shutdownDrainMs ?? DEFAULT_SHUTDOWN_DRAIN_MS).catch(() => void 0);
+    await consolidator.shutdown();
+    this.backendSessionId = null;
+  }
+  /** Preserve a backend-retired session's durable windows for the replacement. */
+  async prepareForReplacement() {
+    const consolidator = this.consolidator;
+    const sessionId = this.backendSessionId;
+    this.consolidator = null;
+    this.backendSessionId = null;
+    if (!consolidator || !sessionId) return;
+    this.sessionsToRehome.add(sessionId);
+    await consolidator.shutdown();
+    await consolidator.drainSends(this.deps.shutdownDrainMs ?? DEFAULT_SHUTDOWN_DRAIN_MS).catch(() => void 0);
+  }
+  async rehomePendingWindows(outbox, replacementSessionId) {
+    const sessionIds = await outbox.enumerateSessions();
+    for (const oldSessionId of sessionIds) {
+      if (oldSessionId === replacementSessionId) continue;
+      const pending = await outbox.listPending(oldSessionId);
+      if (pending.valid.length === 0) continue;
+      let eligible = this.sessionsToRehome.has(oldSessionId);
+      if (!eligible && this.deps.getBackendSession) {
+        try {
+          const oldSession = await this.deps.getBackendSession(oldSessionId);
+          const replacement = this.deps.getSession();
+          eligible = Boolean(
+            oldSession && replacement && oldSession.status === "INACTIVE" && oldSession.userId === replacement.userId && oldSession.projectPath === replacement.projectPath
+          );
+        } catch (error) {
+          this.deps.logger.warn("[tool-activity] Could not verify prior Agy session for rehome", {
+            oldSessionId,
+            error: String(error)
+          });
+        }
+      }
+      if (!eligible) continue;
+      for (const envelope of pending.valid) {
+        const rehomed = { ...envelope, backendSessionId: replacementSessionId };
+        await outbox.persist(replacementSessionId, rehomed);
+        await outbox.prune(oldSessionId, envelope.clientEventId);
+      }
+      this.sessionsToRehome.delete(oldSessionId);
+      this.deps.logger.info("[tool-activity] Rehomed durable Agy windows", {
+        oldSessionId,
+        replacementSessionId,
+        count: pending.valid.length
+      });
+    }
+  }
+  buildTransport() {
+    const sendOnce = async (sessionId, envelope, override) => {
+      const session = this.deps.getSession();
+      if (!session || session.sessionId !== sessionId) {
+        throw terminalSessionError(sessionId);
+      }
+      const encrypted = (0, import_codevibe_core4.encryptForEmit)(
+        override?.sessionKey ?? session.sessionKey ?? null,
+        session.sessionIsEncrypted ?? false,
+        TOOL_ACTIVITY_CONTENT,
+        { manifest: envelope.manifest }
+      );
+      if (!encrypted) {
+        throw new Error("[tool-activity] encrypted Agy session has no key (retryable)");
+      }
+      const sessionKeyGen = override?.sessionKeyGen ?? session.sessionKeyGen;
+      const input = {
+        sessionId,
+        type: import_codevibe_core4.EventType.TOOL_ACTIVITY,
+        source: import_codevibe_core4.EventSource.DESKTOP,
+        content: encrypted.content,
+        metadata: encrypted.metadata,
+        timestamp: envelope.windowStart,
+        clientEventId: envelope.clientEventId,
+        ...encrypted.isEncrypted ? { isEncrypted: true } : {},
+        ...encrypted.isEncrypted && sessionKeyGen ? { expectedSessionKeyGen: sessionKeyGen } : {}
+      };
+      await this.deps.createEvent(input);
+    };
+    return {
+      send: async (sessionId, envelope) => {
+        try {
+          await sendOnce(sessionId, envelope);
+        } catch (error) {
+          if ((0, import_codevibe_core4.isTerminalSessionError)(error)) {
+            throw new Error(`[tool-activity] Agy session ${sessionId} retired; awaiting replacement`);
+          }
+          if ((0, import_codevibe_core4.isSessionKeyStaleError)(error) && this.deps.refreshSessionKey) {
+            const refreshed = await this.deps.refreshSessionKey(sessionId);
+            if (refreshed) {
+              await sendOnce(sessionId, envelope, refreshed);
+              return;
+            }
+          }
+          throw error;
+        }
+      }
+    };
+  }
+};
+
 // src/server.ts
 var MOBILE_PROMPT_FLOOR_RECENCY_MS = 12e4;
 var LAUNCH_SETTLE_TIMEOUT_MS = 3e3;
@@ -3051,6 +3300,8 @@ var McpServer = class _McpServer {
      *  under this single sessionId. /resume does NOT create a new
      *  session — same row. */
     this.session = null;
+    this.transcriptHandlers = /* @__PURE__ */ new Set();
+    this.toolActivityKeyRefresh = null;
     // E1 (§4/§6a-4) — per-promptId durable raise entries for the agy producer.
     // Keyed by the E1 promptId (= derive(ownerToken)); each holds the SECRET
     // ownerToken so a resume/retirement re-raise re-commits the SAME promptId
@@ -3191,7 +3442,21 @@ var McpServer = class _McpServer {
     this.wrapperPid = options.wrapperPid ?? null;
     this.cliLogPath = options.cliLogPath ?? null;
     this.launchSettleTimeoutMs = options.launchSettleTimeoutMs ?? LAUNCH_SETTLE_TIMEOUT_MS;
-    this.appSyncClient = options.appSyncClient ?? new import_codevibe_core4.AppSyncClient();
+    this.appSyncClient = options.appSyncClient ?? new import_codevibe_core5.AppSyncClient();
+    this.toolActivity = options.toolActivityIntegration === void 0 ? new AgyToolActivityIntegration({
+      logger,
+      createEvent: (input) => this.appSyncClient.createEvent(input),
+      getSession: () => this.session,
+      refreshSessionKey: (sessionId) => this.refreshToolActivitySessionKey(sessionId),
+      getBackendSession: async (sessionId) => {
+        const session = await this.appSyncClient.getSession(sessionId);
+        return session ? {
+          status: session.status,
+          userId: session.userId,
+          projectPath: session.projectPath
+        } : null;
+      }
+    }) : options.toolActivityIntegration;
     this.workingDirectory = process.cwd();
     this.approvalDetector = options.approvalDetector ?? new ApprovalDetector(options.detectorOptions);
     this.paneObserver = options.paneObserver ?? new TmuxPaneObserver();
@@ -3243,9 +3508,9 @@ var McpServer = class _McpServer {
     this.stopRequestedDuringCreate = false;
     this.registerSignalHandlers();
     this.startTmuxLifecycleMonitor();
-    await (0, import_codevibe_core4.registerDeviceEncryptionKey)(this.appSyncClient, logger);
+    await (0, import_codevibe_core5.registerDeviceEncryptionKey)(this.appSyncClient, logger);
     if (!this.started) return { httpPort: 0 };
-    (0, import_codevibe_core4.startDeviceKeyWatcher)(this.appSyncClient, logger);
+    (0, import_codevibe_core5.startDeviceKeyWatcher)(this.appSyncClient, logger);
     try {
       const swept = await this.appSyncClient.sweepOrphanSessions({
         agentType: "ANTIGRAVITY",
@@ -3280,9 +3545,14 @@ var McpServer = class _McpServer {
       logger.error("transcript tailer error (non-fatal)", { error: String(err) });
     });
     this.addListener(this.transcriptTailer, "event", (emit) => {
-      void this.handleTranscriptEmit(emit).catch((err) => {
+      const task = this.handleTranscriptEmit(emit).catch((err) => {
         logger.error("handleTranscriptEmit failed", { error: String(err) });
       });
+      this.transcriptHandlers.add(task);
+      void task.then(
+        () => this.transcriptHandlers.delete(task),
+        () => this.transcriptHandlers.delete(task)
+      );
     });
     this.addListener(this.transcriptTailer, "conversation-discovered", (conversationId) => {
       void this.handleConversationDiscovered(conversationId).catch((err) => {
@@ -3378,17 +3648,29 @@ var McpServer = class _McpServer {
       }
     }
     this.listenerHandles = [];
+    await Promise.allSettled([...this.transcriptHandlers]);
     if (this.session) {
       try {
         this.appSyncClient.stopHeartbeat(this.session.sessionId);
       } catch {
       }
+      try {
+        await this.toolActivity?.stop();
+      } catch (err) {
+        logger.warn("[tool-activity] Agy shutdown drain failed", { error: String(err) });
+      }
       const retired = await this.deactivateLaunchRow(this.session.sessionId);
       if (!retired) {
         hostedRetirementError = new Error(
           `Failed to retire hosted Antigravity session ${this.session.sessionId}`
         );
       }
+    } else {
+      try {
+        await this.toolActivity?.stop();
+      } catch (err) {
+        logger.warn("[tool-activity] Agy shutdown cleanup failed", { error: String(err) });
+      }
     }
     this.unregisterSignalHandlers();
     try {
@@ -3525,8 +3807,9 @@ var McpServer = class _McpServer {
     const projectPath = process.cwd();
     this.pendingLaunchSessionId = sessionId;
     let sessionKey = null;
+    let sessionKeyGen = null;
     try {
-      const result = await (0, import_codevibe_core4.resumeOrCreateSession)(
+      const result = await (0, import_codevibe_core5.resumeOrCreateSession)(
         {
           sessionId,
           userId,
@@ -3542,6 +3825,7 @@ var McpServer = class _McpServer {
         logger
       );
       sessionKey = result.sessionKey ?? null;
+      sessionKeyGen = result.sessionKeyGen ?? null;
     } catch (err) {
       if (this.pendingLaunchSessionId === sessionId) this.pendingLaunchSessionId = null;
       const msg = String(err);
@@ -3583,6 +3867,7 @@ var McpServer = class _McpServer {
       subscriptionActive: false,
       metadata: { wrapperPid: this.wrapperPid ?? void 0, launch: true },
       sessionKey,
+      sessionKeyGen,
       // (#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
@@ -3592,6 +3877,14 @@ var McpServer = class _McpServer {
       sessionIsEncrypted: !!sessionKey
     };
     this.pendingLaunchSessionId = null;
+    try {
+      await this.toolActivity?.start(sessionId);
+    } catch (error) {
+      logger.warn("[tool-activity] Agy consolidator unavailable; retaining raw TOOL_USE fallback", {
+        sessionId,
+        error: String(error)
+      });
+    }
     try {
       const stop = this.appSyncClient.subscribeToEvents(
         sessionId,
@@ -3709,20 +4002,36 @@ var McpServer = class _McpServer {
       this.approvalDetector.registerPendingCall(reg);
     }
     for (const input of mapped.events) {
-      if (input.type === import_codevibe_core4.EventType.TOOL_USE && typeof input.metadata === "object" && input.metadata) {
+      if (input.type === import_codevibe_core5.EventType.USER_PROMPT || input.type === import_codevibe_core5.EventType.ASSISTANT_RESPONSE || input.type === import_codevibe_core5.EventType.NOTIFICATION) {
+        await this.flushToolActivityAtBoundary(input.type);
+      }
+      if (input.type === import_codevibe_core5.EventType.TOOL_USE && typeof input.metadata === "object" && input.metadata) {
         const meta = input.metadata;
         const resultStep = typeof meta.step_index === "number" ? meta.step_index : void 0;
         const agyType = typeof meta.agy_type === "string" ? meta.agy_type : void 0;
         if (resultStep !== void 0 && agyType) {
-          this.approvalDetector.clearOnResultEvent({
+          const matchedCall = this.approvalDetector.clearOnResultEvent({
             conversationId,
             resultStepIndex: resultStep,
             toolType: agyType,
             resultByteOffset: byteOffset
           });
+          try {
+            const disposition = await this.toolActivity?.observeResult(emit, matchedCall);
+            if (disposition && disposition !== "closed") {
+              continue;
+            }
+          } catch (error) {
+            logger.warn("[tool-activity] Agy result observation failed; emitting raw TOOL_USE fallback", {
+              sessionId: session.sessionId,
+              conversationId,
+              resultStep,
+              error: String(error)
+            });
+          }
         }
       }
-      if (input.type === import_codevibe_core4.EventType.USER_PROMPT && input.source === import_codevibe_core4.EventSource.DESKTOP) {
+      if (input.type === import_codevibe_core5.EventType.USER_PROMPT && input.source === import_codevibe_core5.EventSource.DESKTOP) {
         const clearedPromptIds = this.approvalDetector.onPanePromptCleared();
         await this.resolveAcceptedInputPrompts(session, clearedPromptIds);
         const dedupe = this.mobileDeduper.consumeIfDuplicate(session.sessionId, input.content);
@@ -3735,9 +4044,7 @@ var McpServer = class _McpServer {
         }
       }
       try {
-        const outbound = this.encryptOutbound(session, input);
-        if (!outbound) continue;
-        await this.appSyncClient.createEvent(outbound);
+        if (!await this.createEncryptedEvent(session, input)) continue;
       } catch (err) {
         logger.error("createEvent failed", {
           sessionId: session.sessionId,
@@ -3747,6 +4054,67 @@ var McpServer = class _McpServer {
       }
     }
   }
+  async flushToolActivityAtBoundary(boundary) {
+    try {
+      await this.toolActivity?.flush();
+    } catch (error) {
+      logger.warn("[tool-activity] Agy boundary flush failed; retaining individual event", {
+        boundary,
+        error: String(error)
+      });
+    }
+  }
+  async refreshToolActivitySessionKey(sessionId) {
+    if (this.toolActivityKeyRefresh?.sessionId === sessionId) {
+      return this.toolActivityKeyRefresh.promise;
+    }
+    const promise = this.loadAndInstallToolActivitySessionKey(sessionId);
+    this.toolActivityKeyRefresh = { sessionId, promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.toolActivityKeyRefresh?.promise === promise) {
+        this.toolActivityKeyRefresh = null;
+      }
+    }
+  }
+  async loadAndInstallToolActivitySessionKey(sessionId) {
+    const lifecycleGen = this.lifecycleGen;
+    const expectedSession = this.session;
+    try {
+      const session = await this.appSyncClient.getSession(sessionId);
+      if (session?.status === import_codevibe_core5.SessionStatus.INACTIVE) {
+        const terminal = new Error(`Antigravity session is no longer active: ${sessionId}`);
+        terminal.errorType = "SessionTerminal";
+        throw terminal;
+      }
+      if (!session || session.status !== import_codevibe_core5.SessionStatus.ACTIVE || !session.isEncrypted) {
+        return null;
+      }
+      const sessionKeyGen = session.sessionKeyGen ?? null;
+      const encryptedKeys = session.encryptedKeys ?? [];
+      if (encryptedKeys.length === 0) return null;
+      const sessionKey = await import_codevibe_core5.keychainManager.getSessionKey(
+        sessionId,
+        encryptedKeys,
+        sessionKeyGen
+      );
+      if (!sessionKey) return null;
+      const liveSession = this.session;
+      if (lifecycleGen !== this.lifecycleGen || !this.started || !expectedSession || liveSession !== expectedSession || liveSession.sessionId !== sessionId) return null;
+      liveSession.sessionKey = sessionKey;
+      liveSession.sessionKeyGen = sessionKeyGen;
+      liveSession.sessionIsEncrypted = true;
+      return { sessionKey, sessionKeyGen };
+    } catch (error) {
+      if ((0, import_codevibe_core5.isTerminalSessionError)(error)) throw error;
+      logger.warn("[tool-activity] Agy session-key refresh failed; window remains retryable", {
+        sessionId,
+        error: String(error)
+      });
+      return null;
+    }
+  }
   /**
    * (#638) THE single encrypt-or-fail-closed decision for EVERY mobile-visible
    * emit, delegated to @quantiya/codevibe-core's encryptForEmit so all three
@@ -3759,7 +4127,7 @@ var McpServer = class _McpServer {
    * an encrypted keyless one (drop).
    */
   encryptOutbound(session, input) {
-    const enc = (0, import_codevibe_core4.encryptForEmit)(
+    const enc = (0, import_codevibe_core5.encryptForEmit)(
       session.sessionKey ?? null,
       session.sessionIsEncrypted ?? false,
       input.content,
@@ -3779,9 +4147,28 @@ var McpServer = class _McpServer {
       ...input,
       content: enc.content,
       metadata: enc.metadata,
-      isEncrypted: true
+      isEncrypted: true,
+      ...session.sessionKeyGen ? { expectedSessionKeyGen: session.sessionKeyGen } : {}
     };
   }
+  /** Encrypt and send one individual event, refreshing a stale session key once. */
+  async createEncryptedEvent(session, input) {
+    const lifecycleGen = this.lifecycleGen;
+    const sendOnce = async () => {
+      if (lifecycleGen !== this.lifecycleGen || !this.started || this.session !== session || input.sessionId !== session.sessionId) return null;
+      const outbound = this.encryptOutbound(session, input);
+      if (!outbound) return null;
+      return this.appSyncClient.createEvent(outbound);
+    };
+    try {
+      return await sendOnce();
+    } catch (error) {
+      if (!(0, import_codevibe_core5.isSessionKeyStaleError)(error)) throw error;
+      const refreshed = await this.refreshToolActivitySessionKey(session.sessionId);
+      if (!refreshed) throw error;
+      return sendOnce();
+    }
+  }
   // ─── E1 missed-prompt recovery (§4/§6a) — in-memory ledger + raise helpers ───
   //
   // The authoritative ledger is the in-memory `e1PromptRaises` Map (see its field
@@ -3797,7 +4184,7 @@ var McpServer = class _McpServer {
    * NOTIFICATION carrier, no fabricated options).
    */
   newE1Raise(sessionId, mobileActionable, title) {
-    const { record } = (0, import_codevibe_core4.newPromptRaise)({
+    const { record } = (0, import_codevibe_core5.newPromptRaise)({
       sessionId,
       producerKind: "PLUGIN_APPROVAL",
       mobileActionable,
@@ -3833,8 +4220,8 @@ var McpServer = class _McpServer {
       try {
         const ack = await this.appSyncClient.createEvent({
           sessionId: entry.record.sessionId || sessionId,
-          type: import_codevibe_core4.EventType.NOTIFICATION,
-          source: import_codevibe_core4.EventSource.DESKTOP,
+          type: import_codevibe_core5.EventType.NOTIFICATION,
+          source: import_codevibe_core5.EventSource.DESKTOP,
           resolvedPromptId: promptId,
           ownerToken: entry.record.ownerToken
         });
@@ -3895,17 +4282,16 @@ var McpServer = class _McpServer {
     const bannerText = "\u26A0\uFE0F A prompt is waiting in your desktop terminal, but its options could not be shown here. Please answer it on your desktop.";
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core4.EventType.NOTIFICATION,
-      source: import_codevibe_core4.EventSource.DESKTOP,
+      type: import_codevibe_core5.EventType.NOTIFICATION,
+      source: import_codevibe_core5.EventSource.DESKTOP,
       content: bannerText,
       metadata: { e1SuppressedPrompt: true },
-      ...(0, import_codevibe_core4.raiseFieldsFromRecord)(record),
+      ...(0, import_codevibe_core5.raiseFieldsFromRecord)(record),
       notificationText: bannerText,
-      timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: session.sessionId })
+      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
     };
-    const outbound = this.encryptOutbound(session, input);
-    if (!outbound) return false;
-    await this.appSyncClient.createEvent(outbound);
+    await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.NOTIFICATION);
+    if (!await this.createEncryptedEvent(session, input)) return false;
     logger.info("E1: emitted suppressed-prompt badge carrier (mobileActionable=false)", {
       sessionId: session.sessionId,
       promptId: record.promptId
@@ -4072,16 +4458,15 @@ var McpServer = class _McpServer {
         if (actionable) {
           const input = {
             sessionId: session.sessionId,
-            type: import_codevibe_core4.EventType.INTERACTIVE_PROMPT,
-            source: import_codevibe_core4.EventSource.DESKTOP,
+            type: import_codevibe_core5.EventType.INTERACTIVE_PROMPT,
+            source: import_codevibe_core5.EventSource.DESKTOP,
             content: entry.contentPlain,
             metadata: entry.metadataPlain ?? {},
-            ...(0, import_codevibe_core4.raiseFieldsFromRecord)(rec),
-            timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: session.sessionId })
+            ...(0, import_codevibe_core5.raiseFieldsFromRecord)(rec),
+            timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
           };
-          const outbound = this.encryptOutbound(session, input);
-          if (!outbound) return false;
-          await this.appSyncClient.createEvent(outbound);
+          await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.INTERACTIVE_PROMPT);
+          if (!await this.createEncryptedEvent(session, input)) return false;
         } else {
           rec.mobileActionable = false;
           if (!await this.emitSuppressedPromptCarrier(session, rec)) return false;
@@ -4219,6 +4604,14 @@ var McpServer = class _McpServer {
         }
         this.subscription = null;
       }
+      try {
+        await this.toolActivity?.prepareForReplacement();
+      } catch (error) {
+        logger.warn("[tool-activity] Failed to settle retired Agy session", {
+          sessionId: old.sessionId,
+          error: String(error)
+        });
+      }
       this.session = null;
       await this.ensureLaunchSession();
       if (this.session) await this.drainE1RetirementPark();
@@ -4253,10 +4646,10 @@ var McpServer = class _McpServer {
     }
     const result = { ...evt };
     try {
-      result.content = import_codevibe_core4.cryptoService.decryptContent(evt.content, session.sessionKey);
+      result.content = import_codevibe_core5.cryptoService.decryptContent(evt.content, session.sessionKey);
       const rawMeta = parseMaybeJson(evt.metadata);
       if (rawMeta && typeof rawMeta === "object" && typeof rawMeta.encrypted === "string") {
-        const decryptedMeta = import_codevibe_core4.cryptoService.decryptMetadata(
+        const decryptedMeta = import_codevibe_core5.cryptoService.decryptMetadata(
           rawMeta.encrypted,
           session.sessionKey
         );
@@ -4335,6 +4728,7 @@ var McpServer = class _McpServer {
       });
       return;
     }
+    await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.INTERACTIVE_PROMPT);
     const e1existing = this.e1PromptRaises.get(state.promptId);
     const e1rec = e1existing ? e1existing.record : this.newE1Raise(session.sessionId, true);
     if (!e1existing) state.promptId = e1rec.promptId;
@@ -4373,26 +4767,24 @@ var McpServer = class _McpServer {
     const content = state.paneDisplayHeader || state.matchedPaneHeader || state.pendingCall?.command || state.pendingCall?.filePath || "approval requested";
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core4.EventType.INTERACTIVE_PROMPT,
-      source: import_codevibe_core4.EventSource.DESKTOP,
+      type: import_codevibe_core5.EventType.INTERACTIVE_PROMPT,
+      source: import_codevibe_core5.EventSource.DESKTOP,
       content,
       metadata: optionsForMobile,
       // E1 (§4) — raise identity top-level: promptId + ownerToken/producerKind/
       // mobileActionable (the backend's classifyRaise upserts the open-prompt row).
-      ...(0, import_codevibe_core4.raiseFieldsFromRecord)(e1rec),
+      ...(0, import_codevibe_core5.raiseFieldsFromRecord)(e1rec),
       // Per-conversation monotonic timestamp (event-timestamp-ordering fix
       // v5.4, 2026-05-24). orderingKey scopes the counter to this conv so
       // INTERACTIVE_PROMPT can't be forced to lastMs+1 by a newer event
       // from a sibling conversation under v9's multi-conv-per-session
       // model.
-      timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({
+      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({
         orderingKey: `${session.sessionId}:${state.conversationId}`
       })
     };
     try {
-      const outbound = this.encryptOutbound(session, input);
-      if (!outbound) return;
-      await this.appSyncClient.createEvent(outbound);
+      if (!await this.createEncryptedEvent(session, input)) return;
       this.stashE1RaiseContent(
         e1rec.promptId,
         content,
@@ -4443,7 +4835,7 @@ var McpServer = class _McpServer {
       if (shouldDecrypt && sessionKey) {
         try {
           logger.info("Decrypting attachment", { id: attachment.id });
-          buffer = import_codevibe_core4.cryptoService.decryptData(buffer, sessionKey);
+          buffer = import_codevibe_core5.cryptoService.decryptData(buffer, sessionKey);
           logger.info("Attachment decrypted successfully", {
             id: attachment.id,
             decryptedSize: buffer.length
@@ -4498,7 +4890,7 @@ var McpServer = class _McpServer {
     await this.ensureLaunchSession();
     if (!this.session) return;
     const session = this.session;
-    if (evt.source !== import_codevibe_core4.EventSource.MOBILE) return;
+    if (evt.source !== import_codevibe_core5.EventSource.MOBILE) return;
     if (evt.sessionId !== session.sessionId) {
       logger.warn("Dropping mobile event with mismatched sessionId", {
         expected: session.sessionId,
@@ -4514,14 +4906,14 @@ var McpServer = class _McpServer {
     }
     evt = decrypted;
     await this.markDelivered(evt);
-    if (evt.type === import_codevibe_core4.EventType.USER_PROMPT || evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE) {
+    if (evt.type === import_codevibe_core5.EventType.USER_PROMPT || evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
       const mobileFloorMs = Date.parse(evt.timestamp);
       this.mobilePromptFloorBySession.set(session.sessionId, {
         floorMs: Number.isNaN(mobileFloorMs) ? Date.now() : mobileFloorMs,
         setAtWallMs: Date.now()
       });
     }
-    if (evt.type === import_codevibe_core4.EventType.USER_PROMPT || evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE) {
+    if (evt.type === import_codevibe_core5.EventType.USER_PROMPT || evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
       let promptContent = evt.content;
       const attachments = evt.attachments ?? [];
       if (attachments.length > 0) {
@@ -4560,16 +4952,16 @@ var McpServer = class _McpServer {
       const rawMeta = parseMaybeJson(evt.metadata);
       const meta = rawMeta && typeof rawMeta === "object" ? rawMeta : {};
       const evtAny = evt;
-      const responsePromptId = evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE ? typeof meta.promptId === "string" && meta.promptId || typeof meta.prompt_id === "string" && meta.prompt_id || typeof evtAny.promptId === "string" && evtAny.promptId || typeof evtAny.prompt_id === "string" && evtAny.prompt_id || null : null;
+      const responsePromptId = evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE ? typeof meta.promptId === "string" && meta.promptId || typeof meta.prompt_id === "string" && meta.prompt_id || typeof evtAny.promptId === "string" && evtAny.promptId || typeof evtAny.prompt_id === "string" && evtAny.prompt_id || null : null;
       const advertisedOptionNumbers = Array.from(new Set(
         pendingPrompts.flatMap((prompt) => Object.keys(prompt.submitMap))
       ));
-      const intent = (0, import_codevibe_core4.classifyMobilePromptInput)(
+      const intent = (0, import_codevibe_core5.classifyMobilePromptInput)(
         promptContent,
         advertisedOptionNumbers
       );
       if (intent.kind === "option") {
-        const activePrompt = evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE ? pendingPrompts.find((prompt) => prompt.promptId === responsePromptId) ?? null : pendingPrompts.length === 1 ? pendingPrompts[0] : null;
+        const activePrompt = evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE ? pendingPrompts.find((prompt) => prompt.promptId === responsePromptId) ?? null : pendingPrompts.length === 1 ? pendingPrompts[0] : null;
         if (!activePrompt || !Object.prototype.hasOwnProperty.call(activePrompt.submitMap, intent.option)) {
           logger.warn("Numeric input does not identify one current advertised prompt; dropping", {
             sessionId: session.sessionId,
@@ -4579,7 +4971,7 @@ var McpServer = class _McpServer {
           });
           return;
         }
-        if (evt.type === import_codevibe_core4.EventType.PROMPT_RESPONSE) {
+        if (evt.type === import_codevibe_core5.EventType.PROMPT_RESPONSE) {
           if (responsePromptId !== activePrompt.promptId) {
             logger.warn("PROMPT_RESPONSE does not identify the current advertised prompt; dropping", {
               sessionId: session.sessionId,
@@ -4631,16 +5023,15 @@ var McpServer = class _McpServer {
   async emitPromptSafetyNotification(session, content) {
     const input = {
       sessionId: session.sessionId,
-      type: import_codevibe_core4.EventType.NOTIFICATION,
-      source: import_codevibe_core4.EventSource.DESKTOP,
+      type: import_codevibe_core5.EventType.NOTIFICATION,
+      source: import_codevibe_core5.EventSource.DESKTOP,
       content,
       metadata: { promptSafetyBlocked: true },
-      timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: session.sessionId })
+      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: session.sessionId })
     };
-    const outbound = this.encryptOutbound(session, input);
-    if (!outbound) return;
+    await this.flushToolActivityAtBoundary(import_codevibe_core5.EventType.NOTIFICATION);
     try {
-      await this.appSyncClient.createEvent(outbound);
+      await this.createEncryptedEvent(session, input);
     } catch (error) {
       logger.warn("Failed to emit prompt-safety notification", { error: String(error) });
     }
@@ -4659,7 +5050,7 @@ var McpServer = class _McpServer {
         eventId: evt.eventId,
         sessionId: evt.sessionId,
         timestamp: evt.timestamp,
-        deliveryStatus: import_codevibe_core4.DeliveryStatus.DELIVERED
+        deliveryStatus: import_codevibe_core5.DeliveryStatus.DELIVERED
       });
     } catch (err) {
       logger.warn("updateEventStatus(DELIVERED) failed", {
@@ -4683,7 +5074,7 @@ var McpServer = class _McpServer {
         eventId: evt.eventId,
         sessionId: evt.sessionId,
         timestamp: evt.timestamp,
-        deliveryStatus: import_codevibe_core4.DeliveryStatus.EXECUTED
+        deliveryStatus: import_codevibe_core5.DeliveryStatus.EXECUTED
       });
     } catch (err) {
       logger.warn("updateEventStatus(EXECUTED) failed", {
@@ -4711,15 +5102,14 @@ var McpServer = class _McpServer {
       // orderingKey is session-scoped. Slightly coarser than the
       // per-conv key used by transcript emits, but acceptable because
       // hook-script pushes are off the hot transcript path.
-      timestamp: (0, import_codevibe_core4.prepareEventTimestamp)({ orderingKey: payload.sessionId })
+      timestamp: (0, import_codevibe_core5.prepareEventTimestamp)({ orderingKey: payload.sessionId })
     };
-    const finalInput = this.encryptOutbound(session, input);
-    if (!finalInput) {
+    const created = await this.createEncryptedEvent(session, input);
+    if (!created) {
       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 };
   }
   findSessionByBackendId(backendSessionId) {
@@ -4950,7 +5340,7 @@ 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, {
+  (0, import_codevibe_core5.installDaemonProcessGuards)(logger, {
     onFatal: () => {
       void server.stop().finally(() => process.exit(1));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "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",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "2.0.16",
+    "@quantiya/codevibe-core": "2.0.17",
     "chokidar": "^5.0.0",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",