olakai-cli 0.7.0 → 0.8.0

package/dist/{chunk-75YQWZ4Q.js → chunk-E33XD5CO.js}

@@ -32,7 +32,9 @@ import {
 var TOOL_IDS = [
   "claude-code",
   "codex",
-  "cursor"
+  "cursor",
+  "gemini-cli",
+  "antigravity"
 ];
 var registry = /* @__PURE__ */ new Map();
 function registerPlugin(plugin) {
@@ -81,6 +83,16 @@ var TOOL_DESCRIPTORS = {
     scope: "global",
     hooksPath: (_projectRoot, homeDir) => path.join(homeDir, ".cursor", "hooks.json"),
     source: "CURSOR"
+  },
+  "gemini-cli": {
+    scope: "global",
+    hooksPath: (_projectRoot, homeDir) => path.join(homeDir, ".gemini", "settings.json"),
+    source: "GEMINI_CLI"
+  },
+  antigravity: {
+    scope: "global",
+    hooksPath: (_projectRoot, homeDir) => path.join(homeDir, ".gemini", "config", "hooks.json"),
+    source: "ANTIGRAVITY"
   }
 };
 function getToolScope(toolId) {
@@ -786,7 +798,7 @@ function parseTranscript(raw) {
 // src/monitor/plugins/claude-code/hook.ts
 var noopDebug = () => {
 };
-function extractFromTranscript(transcriptPath, debugLog4 = noopDebug) {
+function extractFromTranscript(transcriptPath, debugLog6 = noopDebug) {
   const empty = {
     prompt: "",
     response: "",
@@ -804,7 +816,7 @@ function extractFromTranscript(transcriptPath, debugLog4 = noopDebug) {
   try {
     raw = fs4.readFileSync(transcriptPath, "utf-8");
   } catch (err) {
-    debugLog4("transcript-read-failed", {
+    debugLog6("transcript-read-failed", {
       transcriptPath,
       error: err.message
     });
@@ -1060,8 +1072,8 @@ function mergeCodexHooks(existing, events = SUPPORTED_HOOK_EVENT_NAMES) {
   const merged = { ...existing ?? {} };
   for (const event of events) {
     const existingGroups = merged[event] ?? [];
-    const hasOlakaiHook = existingGroups.some(groupContainsOlakaiHandler);
-    if (hasOlakaiHook) {
+    const hasOlakaiHook2 = existingGroups.some(groupContainsOlakaiHandler);
+    if (hasOlakaiHook2) {
       merged[event] = existingGroups;
     } else {
       merged[event] = [...existingGroups, buildOlakaiHookGroup(event)];
@@ -1397,7 +1409,7 @@ function findRolloutPathForSession(sessionId, sessionsDir = getCodexSessionsDir(
   matches.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return matches[0].path;
 }
-function parseRolloutContent(raw, debugLog4 = noopDebug2) {
+function parseRolloutContent(raw, debugLog6 = noopDebug2) {
   const result = emptyRollout();
   if (!raw) return result;
   const lines = raw.split("\n");
@@ -1414,7 +1426,7 @@ function parseRolloutContent(raw, debugLog4 = noopDebug2) {
     try {
       parsed = JSON.parse(trimmed);
     } catch (err) {
-      debugLog4("rollout-line-parse-failed", {
+      debugLog6("rollout-line-parse-failed", {
         line: trimmed.slice(0, 120),
         error: err.message
       });
@@ -1491,12 +1503,12 @@ function numberOrZero(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 function loadRolloutForSession(sessionId, options = {}) {
-  const debugLog4 = options.debugLog ?? noopDebug2;
+  const debugLog6 = options.debugLog ?? noopDebug2;
   const sessionsDir = options.sessionsDir ?? getCodexSessionsDir();
   const result = emptyRollout();
   const rolloutPath = findRolloutPathForSession(sessionId, sessionsDir);
   if (!rolloutPath) {
-    debugLog4("rollout-not-found", {
+    debugLog6("rollout-not-found", {
       sessionId,
       sessionsDir
     });
@@ -1506,13 +1518,13 @@ function loadRolloutForSession(sessionId, options = {}) {
   try {
     raw = fs9.readFileSync(rolloutPath, "utf-8");
   } catch (err) {
-    debugLog4("rollout-read-failed", {
+    debugLog6("rollout-read-failed", {
       rolloutPath,
       error: err.message
     });
     return result;
   }
-  const parsed = parseRolloutContent(raw, debugLog4);
+  const parsed = parseRolloutContent(raw, debugLog6);
   parsed.rolloutPath = rolloutPath;
   return parsed;
 }
@@ -1565,32 +1577,32 @@ function buildCodexPayload(eventName, eventData, config, rollout = emptyRollout(
   };
 }
 function handleCodexHook(eventName, payloadJson, config, options = {}) {
-  const debugLog4 = options.debugLog ?? noopDebug3;
+  const debugLog6 = options.debugLog ?? noopDebug3;
   if (!isSupportedCodexEvent(eventName)) {
-    debugLog4("hook-unknown-event", eventName);
+    debugLog6("hook-unknown-event", eventName);
     return null;
   }
   if (eventName === "UserPromptSubmit") {
-    debugLog4("user-prompt-submit-dropped", { eventName });
+    debugLog6("user-prompt-submit-dropped", { eventName });
     return null;
   }
   const eventData = payloadJson ?? {};
-  debugLog4("event-parsed", { eventName, eventData });
+  debugLog6("event-parsed", { eventName, eventData });
   const sessionId = typeof eventData.session_id === "string" ? eventData.session_id : "";
   let rollout = emptyRollout();
   if (eventName === "Stop" && sessionId) {
     rollout = loadRolloutForSession(sessionId, {
-      debugLog: debugLog4,
+      debugLog: debugLog6,
       sessionsDir: options.sessionsDir
     });
   }
   const payload = buildCodexPayload(eventName, eventData, config, rollout);
   if (!payload) return null;
   if (!payload.prompt && !payload.response) {
-    debugLog4("payload-empty", { eventName, sessionId });
+    debugLog6("payload-empty", { eventName, sessionId });
     return null;
   }
-  debugLog4("payload-built", payload);
+  debugLog6("payload-built", payload);
   return payload;
 }
 
@@ -2529,6 +2541,1348 @@ function whichCursorOnPath() {
 }
 registerPlugin(cursorPlugin);
 
+// src/monitor/plugins/gemini-cli/index.ts
+import * as fs20 from "fs";
+import { spawnSync as spawnSync4 } from "child_process";
+
+// src/monitor/plugins/gemini-cli/install.ts
+import * as fs18 from "fs";
+import * as os10 from "os";
+import * as path18 from "path";
+
+// src/monitor/plugins/gemini-cli/config.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+function getGeminiCliConfigPath(projectRoot) {
+  return getMonitorConfigPath(projectRoot, "gemini-cli");
+}
+function loadGeminiCliConfig(projectRoot) {
+  const filePath = getGeminiCliConfigPath(projectRoot);
+  try {
+    if (!fs16.existsSync(filePath)) return null;
+    const raw = fs16.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeGeminiCliConfig(projectRoot, config) {
+  const filePath = getGeminiCliConfigPath(projectRoot);
+  const dir = path15.dirname(filePath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
+  }
+  fs16.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  try {
+    fs16.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function deleteGeminiCliConfig(projectRoot) {
+  const filePath = getGeminiCliConfigPath(projectRoot);
+  if (!fs16.existsSync(filePath)) return false;
+  try {
+    fs16.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/monitor/plugins/gemini-cli/paths.ts
+import * as os9 from "os";
+import * as path16 from "path";
+var GEMINI_HOME_DIRNAME = ".gemini";
+var GEMINI_SETTINGS_FILENAME = "settings.json";
+function getGeminiHomeDir(homeDir = os9.homedir()) {
+  return path16.join(homeDir, GEMINI_HOME_DIRNAME);
+}
+function getGeminiSettingsPath(homeDir = os9.homedir()) {
+  return path16.join(getGeminiHomeDir(homeDir), GEMINI_SETTINGS_FILENAME);
+}
+
+// src/monitor/plugins/gemini-cli/settings.ts
+import * as fs17 from "fs";
+import * as path17 from "path";
+var OLAKAI_HOOK_MARKER4 = "olakai monitor hook --tool gemini-cli";
+var GEMINI_HOOK_TIMEOUT_MS = 5e3;
+var SUPPORTED_GEMINI_HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "BeforeModel",
+  "AfterModel",
+  "BeforeTool",
+  "AfterTool"
+];
+function buildOlakaiHookEntry(event) {
+  return {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: `olakai monitor hook --tool gemini-cli ${event}`,
+        timeout: GEMINI_HOOK_TIMEOUT_MS
+      }
+    ]
+  };
+}
+var HOOK_DEFINITIONS = Object.fromEntries(
+  SUPPORTED_GEMINI_HOOK_EVENTS.map((event) => [event, [buildOlakaiHookEntry(event)]])
+);
+function entryContainsOlakaiHook(entry) {
+  if (!Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some(
+    (h) => typeof h?.command === "string" && h.command.includes(OLAKAI_HOOK_MARKER4)
+  );
+}
+function mergeHooksSettings2(existing, definitions = HOOK_DEFINITIONS) {
+  const merged = {
+    ...existing ?? {}
+  };
+  for (const [event, defaultEntries] of Object.entries(definitions)) {
+    const existingEntries = merged[event] ?? [];
+    const hasOlakaiHook2 = existingEntries.some(entryContainsOlakaiHook);
+    if (hasOlakaiHook2) {
+      merged[event] = existingEntries;
+    } else {
+      merged[event] = [...existingEntries, ...defaultEntries];
+    }
+  }
+  return merged;
+}
+function removeOlakaiHooks(existing) {
+  if (!existing) return void 0;
+  const cleaned = {};
+  for (const [event, entries] of Object.entries(existing)) {
+    if (!Array.isArray(entries)) continue;
+    const filteredEntries = [];
+    for (const entry of entries) {
+      const handlers = Array.isArray(entry.hooks) ? entry.hooks : [];
+      const remaining = handlers.filter(
+        (h) => typeof h?.command !== "string" || !h.command.includes(OLAKAI_HOOK_MARKER4)
+      );
+      if (remaining.length === 0 && handlers.length > 0) {
+        continue;
+      }
+      if (remaining.length === handlers.length) {
+        filteredEntries.push(entry);
+      } else {
+        filteredEntries.push({ ...entry, hooks: remaining });
+      }
+    }
+    if (filteredEntries.length > 0) {
+      cleaned[event] = filteredEntries;
+    }
+  }
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function hasOlakaiHooksInstalled2(settings) {
+  const hooks = settings.hooks;
+  if (!hooks) return false;
+  for (const entries of Object.values(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    if (entries.some(entryContainsOlakaiHook)) return true;
+  }
+  return false;
+}
+function readJsonFile2(filePath) {
+  try {
+    if (!fs17.existsSync(filePath)) return null;
+    const content = fs17.readFileSync(filePath, "utf-8");
+    if (!content.trim()) return null;
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile2(filePath, data) {
+  const dir = path17.dirname(filePath);
+  if (!fs17.existsSync(dir)) {
+    fs17.mkdirSync(dir, { recursive: true });
+  }
+  fs17.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// src/monitor/plugins/gemini-cli/install.ts
+var GEMINI_CLI_SOURCE = "gemini-cli";
+var GEMINI_CLI_AGENT_SOURCE = "GEMINI_CLI";
+var GEMINI_CLI_AGENT_CATEGORY = "CODING";
+async function installGeminiCli(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os10.homedir();
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Gemini CLI monitoring for this workspace...\n");
+  console.log(
+    `Note: Gemini CLI hooks are installed globally per user (~/${GEMINI_HOME_DIRNAME}/${GEMINI_SETTINGS_FILENAME}).`
+  );
+  console.log(
+    `Activity from this workspace (${projectRoot}) will be associated with`
+  );
+  console.log("the agent you select below.\n");
+  const agent = await provisionSelfMonitorAgent({
+    projectRoot,
+    source: GEMINI_CLI_AGENT_SOURCE,
+    displayName: "Gemini CLI",
+    category: GEMINI_CLI_AGENT_CATEGORY
+  });
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.error(
+      "Internal error: agent provisioned but no API key returned. Please re-run 'olakai monitor init'."
+    );
+    process.exit(1);
+  }
+  const geminiDir = getGeminiHomeDir(homeDir);
+  if (!fs18.existsSync(geminiDir)) {
+    fs18.mkdirSync(geminiDir, { recursive: true });
+  }
+  const settingsPath = getGeminiSettingsPath(homeDir);
+  const existingSettings = readJsonFile2(settingsPath) ?? {};
+  const mergedHooks = mergeHooksSettings2(existingSettings.hooks);
+  const updatedSettings = {
+    ...existingSettings,
+    hooks: mergedHooks
+  };
+  writeJsonFile2(settingsPath, updatedSettings);
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: GEMINI_CLI_SOURCE,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  writeGeminiCliConfig(projectRoot, monitorConfig);
+  const configPath = getGeminiCliConfigPath(projectRoot);
+  const configRel = path18.relative(projectRoot, configPath);
+  const settingsDisplay = `~/${path18.join(GEMINI_HOME_DIRNAME, GEMINI_SETTINGS_FILENAME)}`;
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(`\u2713 Gemini CLI hooks configured in ${settingsDisplay}`);
+  console.log(`\u2713 Monitor config saved to ${configRel}`);
+  console.log("");
+  console.log(
+    "Congrats! Monitoring is now active. Gemini CLI will report activity to Olakai"
+  );
+  console.log(`on each model turn.`);
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${OLAKAI_DIR}/ is in your .gitignore (it contains your API key)`
+  );
+  console.log(
+    `\u26A0 Gemini CLI hooks require gemini >= 0.26.0. Earlier versions silently skip them.`
+  );
+  console.log("");
+  console.log("To check status:  olakai monitor status --tool gemini-cli");
+  console.log("To disable:       olakai monitor disable --tool gemini-cli");
+  return {
+    agentId: agent.id,
+    agentName: agent.name,
+    source: GEMINI_CLI_SOURCE,
+    monitoringEndpoint
+  };
+}
+async function uninstallGeminiCli(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os10.homedir();
+  const settingsPath = getGeminiSettingsPath(homeDir);
+  const settings = readJsonFile2(settingsPath);
+  if (settings && hasOlakaiHooksInstalled2(settings)) {
+    const cleanedHooks = removeOlakaiHooks(settings.hooks);
+    const next = { ...settings };
+    if (cleanedHooks === void 0) {
+      delete next.hooks;
+    } else {
+      next.hooks = cleanedHooks;
+    }
+    const remainingKeys = Object.keys(next).filter((k) => k !== "hooks");
+    const cleanedHasNoHooks = !next.hooks || Object.keys(next.hooks).length === 0;
+    if (cleanedHasNoHooks && remainingKeys.length === 0) {
+      try {
+        fs18.unlinkSync(settingsPath);
+      } catch {
+      }
+    } else {
+      writeJsonFile2(settingsPath, next);
+    }
+    console.log(
+      `\u2713 Olakai hooks removed from ~/${path18.join(GEMINI_HOME_DIRNAME, GEMINI_SETTINGS_FILENAME)}`
+    );
+  } else {
+    console.log("No Olakai hooks found in Gemini CLI settings.");
+  }
+  if (!opts.keepConfig) {
+    const configPath = getGeminiCliConfigPath(projectRoot);
+    const configRel = path18.relative(projectRoot, configPath);
+    if (deleteGeminiCliConfig(projectRoot)) {
+      console.log(`\u2713 Monitor config removed (${configRel})`);
+    }
+  } else {
+    const configPath = getGeminiCliConfigPath(projectRoot);
+    const configRel = path18.relative(projectRoot, configPath);
+    console.log(`Monitor config retained at ${configRel}`);
+  }
+  console.log("");
+  console.log(
+    "Monitoring disabled. Run 'olakai monitor init --tool gemini-cli' to re-enable."
+  );
+}
+
+// src/monitor/plugins/gemini-cli/status.ts
+import * as os11 from "os";
+import * as path19 from "path";
+async function getGeminiCliStatus(opts) {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  const homeDir = opts?.homeDir ?? os11.homedir();
+  const configPath = getGeminiCliConfigPath(projectRoot);
+  const config = loadGeminiCliConfig(projectRoot);
+  const settings = readJsonFile2(getGeminiSettingsPath(homeDir));
+  const hooksConfigured = settings ? hasOlakaiHooksInstalled2(settings) : false;
+  if (!config) {
+    return {
+      toolId: "gemini-cli",
+      configured: false,
+      hooksConfigured,
+      configPath,
+      notes: hooksConfigured ? [
+        `Gemini CLI hooks present in ~/${GEMINI_HOME_DIRNAME}/${GEMINI_SETTINGS_FILENAME} but no monitor config in this workspace \u2014 re-run init.`
+      ] : []
+    };
+  }
+  return {
+    toolId: "gemini-cli",
+    configured: true,
+    hooksConfigured,
+    agentId: config.agentId,
+    agentName: config.agentName,
+    source: config.source,
+    apiKeyMasked: config.apiKey.slice(0, 12) + "...",
+    monitoringEndpoint: config.monitoringEndpoint,
+    configuredAt: config.createdAt,
+    configPath
+  };
+}
+
+// src/monitor/plugins/gemini-cli/pairing-state.ts
+import * as fs19 from "fs";
+import * as os12 from "os";
+import * as path20 from "path";
+var STATE_DIR_SEGMENTS3 = [".olakai", "gemini-pairings"];
+function getPairingsDir2(homeDir) {
+  return path20.join(homeDir, ...STATE_DIR_SEGMENTS3);
+}
+function sanitizeKeyFragment2(value) {
+  return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function getPairingFile2(sessionId, homeDir) {
+  return path20.join(
+    getPairingsDir2(homeDir),
+    `${sanitizeKeyFragment2(sessionId)}.json`
+  );
+}
+function ensurePairingsDir(homeDir) {
+  const dir = getPairingsDir2(homeDir);
+  try {
+    if (!fs19.existsSync(dir)) {
+      fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  } catch {
+  }
+}
+function readPendingTurn(sessionId, homeDir = os12.homedir()) {
+  if (!sessionId) return null;
+  const file = getPairingFile2(sessionId, homeDir);
+  try {
+    if (!fs19.existsSync(file)) return null;
+    const raw = fs19.readFileSync(file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writePendingTurn(sessionId, pending, homeDir = os12.homedir()) {
+  if (!sessionId) return;
+  ensurePairingsDir(homeDir);
+  const file = getPairingFile2(sessionId, homeDir);
+  try {
+    fs19.writeFileSync(file, JSON.stringify(pending, null, 2) + "\n", "utf-8");
+    try {
+      fs19.chmodSync(file, 384);
+    } catch {
+    }
+  } catch {
+  }
+}
+function updatePendingTurn(sessionId, mutator, homeDir = os12.homedir()) {
+  if (!sessionId) return null;
+  const current = readPendingTurn(sessionId, homeDir) ?? {
+    prompt: "",
+    stashedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    toolCallCount: 0,
+    toolNames: []
+  };
+  const next = mutator(current);
+  writePendingTurn(sessionId, next, homeDir);
+  return next;
+}
+function clearPendingTurn(sessionId, homeDir = os12.homedir()) {
+  if (!sessionId) return;
+  const file = getPairingFile2(sessionId, homeDir);
+  try {
+    if (fs19.existsSync(file)) fs19.unlinkSync(file);
+  } catch {
+  }
+}
+
+// src/monitor/plugins/gemini-cli/hook.ts
+var noopDebug4 = () => {
+};
+var SUPPORTED_EVENTS2 = /* @__PURE__ */ new Set([
+  "SessionStart",
+  "SessionEnd",
+  "BeforeModel",
+  "AfterModel",
+  "BeforeTool",
+  "AfterTool"
+]);
+function isSupportedGeminiEvent(eventName) {
+  return SUPPORTED_EVENTS2.has(eventName);
+}
+function asString2(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asNumber2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((p) => typeof p === "string" ? p : asString2(p?.text) ?? "").join("");
+  }
+  if (isRecord(content) && Array.isArray(content.parts)) {
+    return messageContentToText(content.parts);
+  }
+  return "";
+}
+function extractStructuredPrompt(llmRequest) {
+  if (!isRecord(llmRequest) || !Array.isArray(llmRequest.messages)) {
+    return void 0;
+  }
+  for (let i = llmRequest.messages.length - 1; i >= 0; i--) {
+    const msg = llmRequest.messages[i];
+    if (msg && msg.role === "user") {
+      const text = messageContentToText(msg.content).trim();
+      if (text) return text;
+    }
+  }
+  return void 0;
+}
+function extractStructuredModel(llmRequest) {
+  return isRecord(llmRequest) ? asString2(llmRequest.model) : void 0;
+}
+function extractStructuredResponseDelta(llmResponse) {
+  if (!isRecord(llmResponse)) return "";
+  if (typeof llmResponse.text === "string" && llmResponse.text) {
+    return llmResponse.text;
+  }
+  const parts = llmResponse.candidates?.[0]?.content?.parts;
+  if (Array.isArray(parts)) {
+    return parts.map((p) => typeof p === "string" ? p : asString2(p?.text) ?? "").join("");
+  }
+  return "";
+}
+function isStructuredStreamComplete(llmResponse) {
+  if (!isRecord(llmResponse) || !Array.isArray(llmResponse.candidates)) {
+    return false;
+  }
+  return llmResponse.candidates.some((c) => asString2(c?.finishReason));
+}
+function extractGeminiTokens(payload) {
+  const meta = payload.llm_response?.usageMetadata;
+  if (isRecord(meta)) {
+    const inputTokens2 = asNumber2(meta.promptTokenCount);
+    const outputTokens2 = asNumber2(meta.candidatesTokenCount);
+    const explicitTotal2 = asNumber2(meta.totalTokenCount);
+    const totalTokens2 = explicitTotal2 > 0 ? explicitTotal2 : inputTokens2 + outputTokens2;
+    return { inputTokens: inputTokens2, outputTokens: outputTokens2, totalTokens: totalTokens2 };
+  }
+  const usage = payload.usage ?? {};
+  const inputTokens = asNumber2(usage.input_tokens);
+  const outputTokens = asNumber2(usage.output_tokens);
+  const explicitTotal = asNumber2(usage.total_tokens);
+  const totalTokens = explicitTotal > 0 ? explicitTotal : inputTokens + outputTokens;
+  return { inputTokens, outputTokens, totalTokens };
+}
+function usesStructuredSchema(event) {
+  return isRecord(event.llm_request) || isRecord(event.llm_response);
+}
+function buildPayload(args) {
+  if (!args.prompt && !args.response) return null;
+  const customData = {
+    hookEvent: args.hookEvent ?? "AfterModel",
+    sessionId: args.sessionId,
+    cwd: args.cwd ?? "",
+    inputTokens: args.inputTokens,
+    outputTokens: args.outputTokens,
+    toolCallCount: args.toolCallCount,
+    toolNames: args.toolNames
+  };
+  if (args.sessionStartedAt) {
+    customData.sessionStartedAt = args.sessionStartedAt;
+  }
+  if (args.extra) {
+    customData.stashedExtra = args.extra;
+  }
+  return {
+    prompt: args.prompt,
+    response: args.response,
+    chatId: args.sessionId,
+    source: args.config.source,
+    modelName: args.modelName,
+    tokens: args.totalTokens,
+    customData
+  };
+}
+function buildAfterModelPayload(event, stashed, config) {
+  const sessionId = asString2(event.session_id) ?? `gemini-cli-${Date.now()}`;
+  const prompt = stashed?.prompt ?? asString2(event.prompt) ?? "";
+  const response = asString2(event.response) ?? "";
+  if (!prompt && !response) return null;
+  const { inputTokens, outputTokens, totalTokens } = extractGeminiTokens(event);
+  const modelName = asString2(event.model) ?? stashed?.modelName ?? void 0;
+  return buildPayload({
+    sessionId,
+    prompt,
+    response,
+    modelName,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cwd: asString2(event.cwd) ?? stashed?.cwd,
+    toolCallCount: stashed?.toolCallCount ?? 0,
+    toolNames: stashed?.toolNames ?? [],
+    sessionStartedAt: stashed?.sessionStartedAt,
+    extra: stashed?.extra,
+    hookEvent: event.hook_event_name ?? "AfterModel",
+    config
+  });
+}
+function handleGeminiHook(eventName, payloadJson, config, options = {}) {
+  const debugLog6 = options.debugLog ?? noopDebug4;
+  if (!isSupportedGeminiEvent(eventName)) {
+    debugLog6("hook-unknown-event", eventName);
+    return null;
+  }
+  const event = payloadJson ?? {};
+  debugLog6("event-parsed", { eventName, event });
+  const structured = usesStructuredSchema(event);
+  const sessionId = asString2(event.session_id) ?? "";
+  if (!sessionId) {
+    if (eventName !== "AfterModel") {
+      debugLog6("missing-session-id", { eventName });
+      return null;
+    }
+    if (structured) {
+      const prompt = extractStructuredPrompt(event.llm_request) ?? "";
+      const response = extractStructuredResponseDelta(event.llm_response);
+      const { inputTokens, outputTokens, totalTokens } = extractGeminiTokens(event);
+      const payload2 = buildPayload({
+        sessionId: `gemini-cli-${Date.now()}`,
+        prompt,
+        response,
+        modelName: extractStructuredModel(event.llm_request),
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        cwd: asString2(event.cwd),
+        toolCallCount: 0,
+        toolNames: [],
+        config
+      });
+      if (!payload2) debugLog6("after-model-empty-no-session", { eventName });
+      return payload2;
+    }
+    const payload = buildAfterModelPayload(event, null, config);
+    if (!payload) {
+      debugLog6("after-model-empty-no-session", { eventName });
+      return null;
+    }
+    return payload;
+  }
+  switch (eventName) {
+    case "SessionStart": {
+      writePendingTurn(
+        sessionId,
+        {
+          prompt: "",
+          accumulatedResponse: "",
+          cwd: asString2(event.cwd),
+          sessionStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          stashedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          toolCallCount: 0,
+          toolNames: []
+        },
+        options.homeDir
+      );
+      return null;
+    }
+    case "BeforeModel": {
+      const structuredPrompt = extractStructuredPrompt(event.llm_request);
+      const structuredModel = extractStructuredModel(event.llm_request);
+      updatePendingTurn(
+        sessionId,
+        (current) => ({
+          ...current,
+          prompt: structuredPrompt ?? asString2(event.prompt) ?? "",
+          modelName: structuredModel ?? asString2(event.model) ?? current.modelName,
+          cwd: asString2(event.cwd) ?? current.cwd,
+          stashedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // New model call — reset the streamed-response accumulator and
+          // the per-turn tool counters so they only reflect THIS call.
+          accumulatedResponse: "",
+          toolCallCount: 0,
+          toolNames: []
+        }),
+        options.homeDir
+      );
+      return null;
+    }
+    case "BeforeTool": {
+      const toolName = asString2(event.tool_name);
+      updatePendingTurn(
+        sessionId,
+        (current) => {
+          const nextToolNames = toolName ? current.toolNames.includes(toolName) ? current.toolNames : [...current.toolNames, toolName] : current.toolNames;
+          return {
+            ...current,
+            toolCallCount: current.toolCallCount + 1,
+            toolNames: nextToolNames
+          };
+        },
+        options.homeDir
+      );
+      return null;
+    }
+    case "AfterTool": {
+      return null;
+    }
+    case "AfterModel": {
+      if (!structured) {
+        const stashed = readPendingTurn(sessionId, options.homeDir);
+        const payload2 = buildAfterModelPayload(event, stashed, config);
+        clearPendingTurn(sessionId, options.homeDir);
+        if (!payload2) debugLog6("after-model-empty", { sessionId });
+        return payload2;
+      }
+      const delta = extractStructuredResponseDelta(event.llm_response);
+      const complete = isStructuredStreamComplete(event.llm_response);
+      const structuredPrompt = extractStructuredPrompt(event.llm_request);
+      const structuredModel = extractStructuredModel(event.llm_request);
+      const updated = updatePendingTurn(
+        sessionId,
+        (current) => ({
+          ...current,
+          prompt: structuredPrompt ?? current.prompt,
+          modelName: structuredModel ?? current.modelName,
+          cwd: asString2(event.cwd) ?? current.cwd,
+          accumulatedResponse: (current.accumulatedResponse ?? "") + delta
+        }),
+        options.homeDir
+      );
+      if (!complete) {
+        debugLog6("after-model-streaming", {
+          sessionId,
+          deltaLen: delta.length
+        });
+        return null;
+      }
+      const { inputTokens, outputTokens, totalTokens } = extractGeminiTokens(event);
+      const response = updated?.accumulatedResponse ?? "";
+      const payload = buildPayload({
+        sessionId,
+        prompt: structuredPrompt ?? updated?.prompt ?? "",
+        response,
+        modelName: structuredModel ?? updated?.modelName,
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        cwd: asString2(event.cwd) ?? updated?.cwd,
+        toolCallCount: updated?.toolCallCount ?? 0,
+        toolNames: updated?.toolNames ?? [],
+        sessionStartedAt: updated?.sessionStartedAt,
+        extra: updated?.extra,
+        hookEvent: event.hook_event_name ?? "AfterModel",
+        config
+      });
+      updatePendingTurn(
+        sessionId,
+        (current) => ({
+          ...current,
+          accumulatedResponse: "",
+          toolCallCount: 0,
+          toolNames: []
+        }),
+        options.homeDir
+      );
+      if (!payload) {
+        debugLog6("after-model-empty", { sessionId });
+      } else {
+        debugLog6("payload-built", {
+          sessionId,
+          responseLen: response.length,
+          totalTokens
+        });
+      }
+      return payload;
+    }
+    case "SessionEnd": {
+      clearPendingTurn(sessionId, options.homeDir);
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/monitor/plugins/gemini-cli/index.ts
+var TOOL_ID4 = "gemini-cli";
+function debugLog4(label, data) {
+  if (process.env.OLAKAI_MONITOR_DEBUG !== "1") return;
+  try {
+    const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] gemini-cli/${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
+`;
+    fs20.appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function resolveGeminiCliProjectRoot(eventData, fallbackCwd) {
+  const payloadCwd = typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : fallbackCwd;
+  return findConfiguredWorkspace(payloadCwd, [TOOL_ID4]);
+}
+var geminiCliPlugin = {
+  id: TOOL_ID4,
+  displayName: "Gemini CLI",
+  install(opts) {
+    return installGeminiCli(opts);
+  },
+  uninstall(opts) {
+    return uninstallGeminiCli(opts);
+  },
+  status(opts) {
+    return getGeminiCliStatus(opts);
+  },
+  async handleHook(eventName, payloadJson) {
+    const eventData = payloadJson ?? {};
+    debugLog4("hook-fired", { eventName, hasPayload: payloadJson != null });
+    const projectRoot = resolveGeminiCliProjectRoot(
+      eventData,
+      process.cwd()
+    );
+    if (!projectRoot) {
+      debugLog4("config-not-found", {
+        startDir: typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : process.cwd()
+      });
+      return null;
+    }
+    const config = loadGeminiCliConfig(projectRoot);
+    if (!config) {
+      debugLog4("monitor-config-missing", { projectRoot });
+      return null;
+    }
+    const payload = handleGeminiHook(eventName, eventData, config, {
+      debugLog: debugLog4
+    });
+    if (!payload) return null;
+    return {
+      payload,
+      transport: {
+        endpoint: config.monitoringEndpoint,
+        apiKey: config.apiKey,
+        projectRoot
+      }
+    };
+  },
+  async detectInstalled(opts) {
+    const projectRoot = opts?.projectRoot ?? process.cwd();
+    try {
+      if (fs20.existsSync(getGeminiCliConfigPath(projectRoot))) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      if (fs20.existsSync(getGeminiSettingsPath())) {
+        return true;
+      }
+      if (fs20.existsSync(getGeminiHomeDir())) {
+        return true;
+      }
+    } catch {
+    }
+    return detectGeminiBinaryOnPath();
+  }
+};
+function detectGeminiBinaryOnPath() {
+  try {
+    const probe = spawnSync4(
+      process.platform === "win32" ? "where" : "which",
+      ["gemini"],
+      {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e3
+      }
+    );
+    if (probe.status === 0 && probe.stdout && probe.stdout.toString().trim()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+registerPlugin(geminiCliPlugin);
+
+// src/monitor/plugins/antigravity/index.ts
+import * as fs25 from "fs";
+import { spawnSync as spawnSync5 } from "child_process";
+
+// src/monitor/plugins/antigravity/install.ts
+import * as fs23 from "fs";
+import * as os14 from "os";
+import * as path24 from "path";
+
+// src/monitor/plugins/antigravity/config.ts
+import * as fs21 from "fs";
+import * as path21 from "path";
+function getAntigravityConfigPath(projectRoot) {
+  return getMonitorConfigPath(projectRoot, "antigravity");
+}
+function loadAntigravityConfig(projectRoot) {
+  const filePath = getAntigravityConfigPath(projectRoot);
+  try {
+    if (!fs21.existsSync(filePath)) return null;
+    const raw = fs21.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeAntigravityConfig(projectRoot, config) {
+  const filePath = getAntigravityConfigPath(projectRoot);
+  const dir = path21.dirname(filePath);
+  if (!fs21.existsSync(dir)) {
+    fs21.mkdirSync(dir, { recursive: true });
+  }
+  fs21.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  try {
+    fs21.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function deleteAntigravityConfig(projectRoot) {
+  const filePath = getAntigravityConfigPath(projectRoot);
+  if (!fs21.existsSync(filePath)) return false;
+  try {
+    fs21.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/monitor/plugins/antigravity/paths.ts
+import * as os13 from "os";
+import * as path22 from "path";
+var GEMINI_HOME_DIRNAME2 = ".gemini";
+var ANTIGRAVITY_CONFIG_DIRNAME = "config";
+var ANTIGRAVITY_HOOKS_FILENAME = "hooks.json";
+var ANTIGRAVITY_CLI_DIRNAME = "antigravity-cli";
+function getGeminiHomeDir2(homeDir = os13.homedir()) {
+  return path22.join(homeDir, GEMINI_HOME_DIRNAME2);
+}
+function getGeminiConfigDir(homeDir = os13.homedir()) {
+  return path22.join(getGeminiHomeDir2(homeDir), ANTIGRAVITY_CONFIG_DIRNAME);
+}
+function getGeminiConfigHooksPath(homeDir = os13.homedir()) {
+  return path22.join(getGeminiConfigDir(homeDir), ANTIGRAVITY_HOOKS_FILENAME);
+}
+function getAntigravityCliDir(homeDir = os13.homedir()) {
+  return path22.join(getGeminiHomeDir2(homeDir), ANTIGRAVITY_CLI_DIRNAME);
+}
+
+// src/monitor/plugins/antigravity/settings.ts
+import * as fs22 from "fs";
+import * as path23 from "path";
+var OLAKAI_HOOK_NAME = "olakai-monitor";
+var OLAKAI_HOOK_MARKER5 = "olakai monitor hook --tool antigravity";
+var ANTIGRAVITY_HOOK_TIMEOUT_SECONDS = 30;
+var SUPPORTED_ANTIGRAVITY_HOOK_EVENTS = ["Stop"];
+function buildOlakaiHookCommand(event) {
+  return {
+    type: "command",
+    command: `${OLAKAI_HOOK_MARKER5} ${event}`,
+    timeout: ANTIGRAVITY_HOOK_TIMEOUT_SECONDS
+  };
+}
+function buildOlakaiHookEntry2() {
+  const entry = {};
+  for (const event of SUPPORTED_ANTIGRAVITY_HOOK_EVENTS) {
+    entry[event] = [buildOlakaiHookCommand(event)];
+  }
+  return entry;
+}
+function mergeHooksFile(existing) {
+  const merged = { ...existing ?? {} };
+  merged[OLAKAI_HOOK_NAME] = buildOlakaiHookEntry2();
+  return merged;
+}
+function entryContainsOlakaiHook2(entry) {
+  for (const commands of Object.values(entry)) {
+    if (!Array.isArray(commands)) continue;
+    if (commands.some(
+      (c) => typeof c?.command === "string" && c.command.includes(OLAKAI_HOOK_MARKER5)
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function removeOlakaiHooks2(existing) {
+  if (!existing) return void 0;
+  const cleaned = {};
+  for (const [name, entry] of Object.entries(existing)) {
+    if (name === OLAKAI_HOOK_NAME) continue;
+    if (!entry || typeof entry !== "object") continue;
+    const cleanedEntry = {};
+    for (const [event, commands] of Object.entries(entry)) {
+      if (!Array.isArray(commands)) {
+        cleanedEntry[event] = commands;
+        continue;
+      }
+      const remaining = commands.filter(
+        (c) => typeof c?.command !== "string" || !c.command.includes(OLAKAI_HOOK_MARKER5)
+      );
+      if (remaining.length > 0) {
+        cleanedEntry[event] = remaining;
+      }
+    }
+    if (Object.keys(cleanedEntry).length > 0) {
+      cleaned[name] = cleanedEntry;
+    }
+  }
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function hasOlakaiHook(hooksFile) {
+  if (!hooksFile) return false;
+  for (const entry of Object.values(hooksFile)) {
+    if (entry && entryContainsOlakaiHook2(entry)) return true;
+  }
+  return false;
+}
+function readJsonFile3(filePath) {
+  try {
+    if (!fs22.existsSync(filePath)) return null;
+    const content = fs22.readFileSync(filePath, "utf-8");
+    if (!content.trim()) return null;
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile3(filePath, data) {
+  const dir = path23.dirname(filePath);
+  if (!fs22.existsSync(dir)) {
+    fs22.mkdirSync(dir, { recursive: true });
+  }
+  fs22.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// src/monitor/plugins/antigravity/install.ts
+var ANTIGRAVITY_SOURCE = "antigravity";
+var ANTIGRAVITY_AGENT_SOURCE = "ANTIGRAVITY";
+var ANTIGRAVITY_AGENT_CATEGORY = "CODING";
+var HOOKS_DISPLAY = "~/.gemini/config/hooks.json";
+async function installAntigravity(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os14.homedir();
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Antigravity monitoring for this workspace...\n");
+  console.log(
+    `Note: Antigravity hooks are installed globally per user (${HOOKS_DISPLAY}).`
+  );
+  console.log(
+    `Activity from this workspace (${projectRoot}) will be associated with`
+  );
+  console.log("the agent you select below.\n");
+  const agent = await provisionSelfMonitorAgent({
+    projectRoot,
+    source: ANTIGRAVITY_AGENT_SOURCE,
+    displayName: "Antigravity",
+    category: ANTIGRAVITY_AGENT_CATEGORY
+  });
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.error(
+      "Internal error: agent provisioned but no API key returned. Please re-run 'olakai monitor init'."
+    );
+    process.exit(1);
+  }
+  const configDir = getGeminiConfigDir(homeDir);
+  if (!fs23.existsSync(configDir)) {
+    fs23.mkdirSync(configDir, { recursive: true });
+  }
+  const hooksPath = getGeminiConfigHooksPath(homeDir);
+  const existingHooks = readJsonFile3(hooksPath) ?? {};
+  const mergedHooks = mergeHooksFile(existingHooks);
+  writeJsonFile3(hooksPath, mergedHooks);
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: ANTIGRAVITY_SOURCE,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  writeAntigravityConfig(projectRoot, monitorConfig);
+  const configPath = getAntigravityConfigPath(projectRoot);
+  const configRel = path24.relative(projectRoot, configPath);
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(`\u2713 Antigravity Stop hook configured in ${HOOKS_DISPLAY}`);
+  console.log(`\u2713 Monitor config saved to ${configRel}`);
+  console.log("");
+  console.log(
+    "Congrats! Monitoring is now active. Antigravity will report activity to Olakai"
+  );
+  console.log(`when the agent finishes a turn (Stop hook).`);
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${OLAKAI_DIR}/ is in your .gitignore (it contains your API key)`
+  );
+  console.log(
+    `\u26A0 Antigravity hooks are global (${HOOKS_DISPLAY}) and require an agy build with hooks support.`
+  );
+  console.log(
+    `\u26A0 Turn capture is interactive-only \u2014 headless 'agy -p' runs skip hooks.`
+  );
+  console.log("");
+  console.log("To check status:  olakai monitor status --tool antigravity");
+  console.log("To disable:       olakai monitor disable --tool antigravity");
+  return {
+    agentId: agent.id,
+    agentName: agent.name,
+    source: ANTIGRAVITY_SOURCE,
+    monitoringEndpoint
+  };
+}
+async function uninstallAntigravity(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os14.homedir();
+  const hooksPath = getGeminiConfigHooksPath(homeDir);
+  const hooksFile = readJsonFile3(hooksPath);
+  if (hooksFile && hasOlakaiHook(hooksFile)) {
+    const cleaned = removeOlakaiHooks2(hooksFile);
+    if (cleaned === void 0) {
+      try {
+        fs23.unlinkSync(hooksPath);
+      } catch {
+      }
+    } else {
+      writeJsonFile3(hooksPath, cleaned);
+    }
+    console.log(`\u2713 Olakai hooks removed from ${HOOKS_DISPLAY}`);
+  } else {
+    console.log("No Olakai hooks found in Antigravity hooks.json.");
+  }
+  if (!opts.keepConfig) {
+    const configPath = getAntigravityConfigPath(projectRoot);
+    const configRel = path24.relative(projectRoot, configPath);
+    if (deleteAntigravityConfig(projectRoot)) {
+      console.log(`\u2713 Monitor config removed (${configRel})`);
+    }
+  } else {
+    const configPath = getAntigravityConfigPath(projectRoot);
+    const configRel = path24.relative(projectRoot, configPath);
+    console.log(`Monitor config retained at ${configRel}`);
+  }
+  console.log("");
+  console.log(
+    "Monitoring disabled. Run 'olakai monitor init --tool antigravity' to re-enable."
+  );
+}
+
+// src/monitor/plugins/antigravity/status.ts
+import * as os15 from "os";
+import * as path25 from "path";
+var HOOKS_DISPLAY2 = "~/.gemini/config/hooks.json";
+async function getAntigravityStatus(opts) {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  const homeDir = opts?.homeDir ?? os15.homedir();
+  const configPath = getAntigravityConfigPath(projectRoot);
+  const config = loadAntigravityConfig(projectRoot);
+  const hooksFile = readJsonFile3(
+    getGeminiConfigHooksPath(homeDir)
+  );
+  const hooksConfigured = hasOlakaiHook(hooksFile);
+  if (!config) {
+    return {
+      toolId: "antigravity",
+      configured: false,
+      hooksConfigured,
+      configPath,
+      notes: hooksConfigured ? [
+        `Antigravity hooks present in ${HOOKS_DISPLAY2} but no monitor config in this workspace \u2014 re-run init.`
+      ] : []
+    };
+  }
+  return {
+    toolId: "antigravity",
+    configured: true,
+    hooksConfigured,
+    agentId: config.agentId,
+    agentName: config.agentName,
+    source: config.source,
+    apiKeyMasked: config.apiKey.slice(0, 12) + "...",
+    monitoringEndpoint: config.monitoringEndpoint,
+    configuredAt: config.createdAt,
+    configPath
+  };
+}
+
+// src/monitor/plugins/antigravity/hook.ts
+import * as fs24 from "fs";
+
+// src/monitor/plugins/antigravity/transcript.ts
+var USER_REQUEST_RE = /<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/;
+function parseTranscriptLines(raw) {
+  const lines = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object") {
+        lines.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return lines;
+}
+function asContentString(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractPrompt(lines) {
+  let lastContent = null;
+  for (const line of lines) {
+    if (line?.type === "USER_INPUT") {
+      lastContent = asContentString(line.content);
+    }
+  }
+  if (lastContent === null) return "";
+  const match = USER_REQUEST_RE.exec(lastContent);
+  if (match) {
+    return match[1].trim();
+  }
+  return lastContent.trim();
+}
+function extractResponse(lines) {
+  let lastContent = null;
+  for (const line of lines) {
+    if (line?.type === "PLANNER_RESPONSE") {
+      lastContent = asContentString(line.content);
+    }
+  }
+  if (lastContent === null) return "";
+  return lastContent.trim();
+}
+
+// src/monitor/plugins/antigravity/hook.ts
+var noopDebug5 = () => {
+};
+var SUPPORTED_EVENTS3 = /* @__PURE__ */ new Set(["Stop"]);
+function isSupportedAntigravityEvent(eventName) {
+  return SUPPORTED_EVENTS3.has(eventName);
+}
+function asString3(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function getWorkspacePath(payload) {
+  const paths = payload.workspacePaths;
+  if (Array.isArray(paths)) {
+    const first = paths[0];
+    if (typeof first === "string" && first.trim()) return first;
+  }
+  return void 0;
+}
+function extractFromTranscript2(transcriptPath, debugLog6 = noopDebug5) {
+  if (!transcriptPath) return { prompt: "", response: "" };
+  let raw;
+  try {
+    raw = fs24.readFileSync(transcriptPath, "utf-8");
+  } catch (err) {
+    debugLog6("transcript-read-failed", {
+      transcriptPath,
+      error: err.message
+    });
+    return { prompt: "", response: "" };
+  }
+  const lines = parseTranscriptLines(raw);
+  return {
+    prompt: extractPrompt(lines),
+    response: extractResponse(lines)
+  };
+}
+function buildStopPayload(payload, extracted, config) {
+  const prompt = extracted.prompt ?? "";
+  const response = extracted.response ?? "";
+  if (!prompt.trim() && !response.trim()) return null;
+  const conversationId = asString3(payload.conversationId) ?? `antigravity-${Date.now()}`;
+  const cwd = getWorkspacePath(payload) ?? "";
+  const customData = {
+    hookEvent: "Stop",
+    conversationId,
+    cwd,
+    terminationReason: asString3(payload.terminationReason) ?? ""
+  };
+  return {
+    prompt,
+    response,
+    chatId: conversationId,
+    source: config.source,
+    tokens: 0,
+    customData
+  };
+}
+function handleAntigravityHook(eventName, payloadJson, config, options = {}) {
+  const debugLog6 = options.debugLog ?? noopDebug5;
+  if (!isSupportedAntigravityEvent(eventName)) {
+    debugLog6("hook-unknown-event", eventName);
+    return null;
+  }
+  const payload = payloadJson ?? {};
+  debugLog6("event-parsed", { eventName, payload });
+  const extracted = extractFromTranscript2(payload.transcriptPath, debugLog6);
+  const result = buildStopPayload(payload, extracted, config);
+  if (!result) {
+    debugLog6("stop-empty", { conversationId: payload.conversationId });
+    return null;
+  }
+  debugLog6("payload-built", result);
+  return result;
+}
+
+// src/monitor/plugins/antigravity/index.ts
+var TOOL_ID5 = "antigravity";
+function debugLog5(label, data) {
+  if (process.env.OLAKAI_MONITOR_DEBUG !== "1") return;
+  try {
+    const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] antigravity/${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
+`;
+    fs25.appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function resolveAntigravityProjectRoot(payload, fallbackCwd) {
+  const startDir = getWorkspacePath(payload) ?? fallbackCwd;
+  return findConfiguredWorkspace(startDir, [TOOL_ID5]);
+}
+var antigravityPlugin = {
+  id: TOOL_ID5,
+  displayName: "Antigravity",
+  install(opts) {
+    return installAntigravity(opts);
+  },
+  uninstall(opts) {
+    return uninstallAntigravity(opts);
+  },
+  status(opts) {
+    return getAntigravityStatus(opts);
+  },
+  async handleHook(eventName, payloadJson) {
+    const payload = payloadJson ?? {};
+    debugLog5("hook-fired", { eventName, hasPayload: payloadJson != null });
+    const projectRoot = resolveAntigravityProjectRoot(payload, process.cwd());
+    if (!projectRoot) {
+      debugLog5("config-not-found", {
+        startDir: getWorkspacePath(payload) ?? process.cwd()
+      });
+      return null;
+    }
+    const config = loadAntigravityConfig(projectRoot);
+    if (!config) {
+      debugLog5("monitor-config-missing", { projectRoot });
+      return null;
+    }
+    const result = handleAntigravityHook(eventName, payload, config, {
+      debugLog: debugLog5
+    });
+    if (!result) return null;
+    return {
+      payload: result,
+      transport: {
+        endpoint: config.monitoringEndpoint,
+        apiKey: config.apiKey,
+        projectRoot
+      }
+    };
+  },
+  async detectInstalled(opts) {
+    const projectRoot = opts?.projectRoot ?? process.cwd();
+    try {
+      if (fs25.existsSync(getAntigravityConfigPath(projectRoot))) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      if (fs25.existsSync(getAntigravityCliDir())) {
+        return true;
+      }
+    } catch {
+    }
+    return detectAgyBinaryOnPath();
+  }
+};
+function detectAgyBinaryOnPath() {
+  try {
+    const probe = spawnSync5(
+      process.platform === "win32" ? "where" : "which",
+      ["agy"],
+      {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e3
+      }
+    );
+    if (probe.status === 0 && probe.stdout && probe.stdout.toString().trim()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+registerPlugin(antigravityPlugin);
+
 // src/monitor/install.ts
 async function runMonitorInstall(toolId, opts = {}) {
   const plugin = getPlugin(toolId);
@@ -2575,6 +3929,18 @@ export {
   writeCursorConfig,
   getCursorHooksPath,
   mergeCursorHooks,
+  loadGeminiCliConfig,
+  writeGeminiCliConfig,
+  getGeminiSettingsPath,
+  mergeHooksSettings2 as mergeHooksSettings,
+  readJsonFile2 as readJsonFile,
+  writeJsonFile2 as writeJsonFile,
+  loadAntigravityConfig,
+  writeAntigravityConfig,
+  getGeminiConfigHooksPath,
+  mergeHooksFile,
+  readJsonFile3 as readJsonFile2,
+  writeJsonFile3 as writeJsonFile2,
   getToolScope,
   getToolSource,
   readRegistry,
@@ -2584,4 +3950,4 @@ export {
   formatRegistryTable,
   runMonitorInstall
 };
-//# sourceMappingURL=chunk-75YQWZ4Q.js.map
+//# sourceMappingURL=chunk-E33XD5CO.js.map