@oddessentials/agent-guild 0.11.0 → 0.12.0

package/src/manager/usage.mjs

@@ -12,10 +12,6 @@ const RATE_LIMITED_TTL_MS = 5 * 60 * 1000;
 const CLAUDE_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const CODEX_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
 const CLAUDE_KEYCHAIN_SERVICE = 'Claude Code-credentials';
-const GEMINI_KEYCHAIN_SERVICE = 'gemini-cli-oauth';
-const GEMINI_KEYCHAIN_ACCOUNT = 'main-account';
-const GEMINI_CODE_ASSIST_URL = 'https://cloudcode-pa.googleapis.com/v1internal';
-const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
 
 export class UsageError extends Error {}
 
@@ -258,232 +254,6 @@ function codexWindows(limits) {
   return windows;
 }
 
-// ---- Gemini CLI -----------------------------------------------------------
-
-export function geminiCredentialsFile(env = process.env) {
-  return path.join(env.GEMINI_CLI_HOME || os.homedir(), '.gemini', 'oauth_creds.json');
-}
-
-export function geminiKeychainFile(env = process.env) {
-  return path.join(env.GEMINI_CLI_HOME || os.homedir(), '.gemini', 'gemini-credentials.json');
-}
-
-export function geminiFileKey({ hostname = os.hostname(), username = os.userInfo().username } = {}) {
-  return crypto.scryptSync(GEMINI_KEYCHAIN_SERVICE, `${hostname}-${username}-gemini-cli`, 32);
-}
-
-/**
- * The item Gemini CLI keeps in its own encrypted file when it does not use
- * the OS keychain: AES-256-GCM as iv:tag:ciphertext in hex, over a JSON
- * map of service to account to secret.
- */
-export async function readGeminiFileKeychain(file, { key = geminiFileKey() } = {}) {
-  let raw;
-  try {
-    raw = await fs.promises.readFile(file, 'utf8');
-  } catch {
-    return null;
-  }
-  try {
-    const [iv, tag, encrypted] = raw.trim().split(':').map((part) => Buffer.from(part, 'hex'));
-    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv, { authTagLength: 16 });
-    decipher.setAuthTag(tag);
-    const json = Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf8');
-    return JSON.parse(json)?.[GEMINI_KEYCHAIN_SERVICE]?.[GEMINI_KEYCHAIN_ACCOUNT] ?? null;
-  } catch {
-    throw new UsageError(`Gemini CLI credentials file ${shortPath(file)} could not be decrypted`);
-  }
-}
-
-export function geminiKeychainLookup(platform) {
-  if (platform === 'darwin') return { file: 'security', args: ['find-generic-password', '-s', GEMINI_KEYCHAIN_SERVICE, '-a', GEMINI_KEYCHAIN_ACCOUNT, '-w'] };
-  // keytar stores libsecret items with the attributes "service" and "account".
-  if (platform === 'linux') return { file: 'secret-tool', args: ['lookup', 'service', GEMINI_KEYCHAIN_SERVICE, 'account', GEMINI_KEYCHAIN_ACCOUNT] };
-  return null;
-}
-
-/**
- * What the OS keychain holds for Gemini CLI: the item, or that it is
- * absent, that there is no keychain to ask (so the tool keeps its own
- * encrypted file instead), or that it is one this manager cannot read.
- */
-export async function readGeminiKeychainItem(platform) {
-  const spec = geminiKeychainLookup(platform);
-  if (!spec) return { status: platform === 'win32' ? 'unreadable' : 'unavailable' };
-  try {
-    const { stdout } = await runSpec(spec, { timeoutMs: 30000 });
-    return stdout.trim() ? { status: 'found', item: stdout } : { status: 'absent' };
-  } catch (err) {
-    // security exits 44 for a missing item; secret-tool exits 1 for one and
-    // says why on stderr when it has no Secret Service at all.
-    if (platform === 'darwin' && err.code === 44) return { status: 'absent' };
-    if (platform === 'linux' && err.code === 1 && !String(err.stderr || '').trim()) return { status: 'absent' };
-    return { status: 'unavailable' };
-  }
-}
-
-/** Gemini CLI's own storage choice, read from the environment the tool runs with. */
-export function geminiStorageMode(env = process.env) {
-  return { encrypted: env.GEMINI_FORCE_ENCRYPTED_FILE_STORAGE === 'true', fileStorage: env.GEMINI_FORCE_FILE_STORAGE === 'true' };
-}
-
-/**
- * Reads the sign-in from where Gemini CLI keeps it: oauth_creds.json, or
- * with GEMINI_FORCE_ENCRYPTED_FILE_STORAGE the OS keychain item, or its
- * encrypted file when GEMINI_FORCE_FILE_STORAGE is set or there is no
- * keychain. An absent item falls back to oauth_creds.json, as the tool
- * itself migrates it from there.
- */
-export async function readGeminiCredentials({
-  file = geminiCredentialsFile(),
-  keychainFile = geminiKeychainFile(),
-  platform = process.platform,
-  encrypted = false,
-  fileStorage = false,
-  readKeychain = readGeminiKeychainItem,
-  readFileKeychain = readGeminiFileKeychain,
-} = {}) {
-  let raw = null;
-  if (encrypted) {
-    const keychain = fileStorage ? { status: 'unavailable' } : await readKeychain(platform);
-    if (keychain.status === 'found') raw = keychain.item;
-    else if (keychain.status === 'unavailable') raw = await readFileKeychain(keychainFile);
-    else if (keychain.status === 'unreadable') throw new UsageError('Gemini CLI keeps its sign-in in the Windows Credential Manager, which cannot be read from here');
-  }
-  if (raw && raw.trim()) {
-    let item;
-    try { item = JSON.parse(raw); } catch { throw new UsageError('Gemini CLI credentials could not be parsed'); }
-    const token = item?.token ?? item;
-    if (typeof token?.accessToken !== 'string' || !token.accessToken) throw new UsageError('Gemini CLI credentials could not be parsed');
-    return { accessToken: token.accessToken, refreshToken: token.refreshToken || null, expiresAt: Number(token.expiresAt) || null, client: null };
-  }
-  let legacy;
-  try {
-    legacy = JSON.parse(await fs.promises.readFile(file, 'utf8'));
-  } catch {
-    throw notSignedIn(`Gemini CLI is not signed in on this machine (no "${GEMINI_KEYCHAIN_SERVICE}" keychain item or ${shortPath(file)})`);
-  }
-  if (typeof legacy?.access_token !== 'string' || !legacy.access_token) throw new UsageError('Gemini CLI credentials could not be parsed');
-  const client = typeof legacy.client_id === 'string' && typeof legacy.client_secret === 'string'
-    ? { id: legacy.client_id, secret: legacy.client_secret }
-    : null;
-  return { accessToken: legacy.access_token, refreshToken: legacy.refresh_token || null, expiresAt: Number(legacy.expiry_date) || null, client };
-}
-
-const geminiClients = new Map();
-
-/**
- * The OAuth client Gemini CLI signed the user in with, read from the
- * installed copy that `commandPath` starts. A refresh token can only be
- * refreshed with the client that issued it, and the client belongs to
- * Gemini CLI, so it is not kept here.
- */
-export function geminiOAuthClientFromInstall(commandPath) {
-  if (!commandPath) return null;
-  if (geminiClients.has(commandPath)) return geminiClients.get(commandPath);
-  let client = null;
-  try {
-    let start = fs.realpathSync(commandPath);
-    if (/\.(cmd|bat|ps1)$/i.test(start)) {
-      // npm's shims start node_modules/... relative to their own folder.
-      const refersToGemini = /node_modules[\\/]@google[\\/]gemini-cli/.test(fs.readFileSync(start, 'utf8'));
-      start = refersToGemini ? path.join(path.dirname(start), 'node_modules', '@google', 'gemini-cli') : null;
-    }
-    let dir = start && (fs.statSync(start).isDirectory() ? start : path.dirname(start));
-    for (let depth = 0; dir && depth < 8; depth++) {
-      let name = null;
-      try { name = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).name; } catch { /* keep climbing */ }
-      if (name === '@google/gemini-cli') break;
-      const parent = path.dirname(dir);
-      dir = parent === dir ? null : parent;
-    }
-    for (const sub of dir ? ['bundle', 'dist'] : []) {
-      let files = [];
-      try { files = fs.readdirSync(path.join(dir, sub)).filter((f) => f.endsWith('.js')); } catch { continue; }
-      for (const file of files) {
-        const text = fs.readFileSync(path.join(dir, sub, file), 'latin1');
-        const id = text.match(/OAUTH_CLIENT_ID\s*=\s*"([^"]+)"/)?.[1];
-        const secret = text.match(/OAUTH_CLIENT_SECRET\s*=\s*"([^"]+)"/)?.[1];
-        if (id && secret) { client = { id, secret }; break; }
-      }
-      if (client) break;
-    }
-  } catch {
-    client = null;
-  }
-  geminiClients.set(commandPath, client);
-  return client;
-}
-
-async function refreshGoogleToken(refreshToken, client, fetchImpl) {
-  const body = new URLSearchParams({
-    client_id: client.id,
-    client_secret: client.secret,
-    refresh_token: refreshToken,
-    grant_type: 'refresh_token',
-  });
-  const res = await fetchImpl(GOOGLE_TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
-    body: body.toString(),
-    signal: AbortSignal.timeout(10000),
-  });
-  if (!res.ok) throw new UsageError('Gemini CLI sign-in could not be refreshed; run gemini once to sign in again');
-  const json = await res.json();
-  if (typeof json?.access_token !== 'string') throw new UsageError('Gemini CLI sign-in could not be refreshed; run gemini once to sign in again');
-  return { accessToken: json.access_token, expiresAt: Date.now() + (Number(json.expires_in) || 3600) * 1000 };
-}
-
-/**
- * Asks the Code Assist API the way Gemini CLI does: loadCodeAssist for the
- * account's project and tier (skipped when `project` is known), then
- * retrieveUserQuota for one bucket per model. Returns the refreshed token
- * and project too, so a caller can reuse them.
- */
-export async function fetchGeminiUsage({
-  accessToken, refreshToken = null, expiresAt = null, client = null, project = null, version = null, fetchImpl = fetch,
-} = {}) {
-  let token = { accessToken, expiresAt };
-  if (expiresAt && expiresAt < Date.now() + 60000) {
-    if (!refreshToken || !client) throw new UsageError('Gemini CLI sign-in has expired; run gemini once to refresh it');
-    token = await refreshGoogleToken(refreshToken, client, fetchImpl);
-  }
-  const headers = {
-    Authorization: `Bearer ${token.accessToken}`,
-    'Content-Type': 'application/json',
-    Accept: 'application/json',
-    'User-Agent': `GeminiCLI/${version || '0.62.0'} (agent-guild)`,
-  };
-  const post = async (method, body) => {
-    const res = await fetchImpl(`${GEMINI_CODE_ASSIST_URL}:${method}`, {
-      method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(10000),
-    });
-    if (!res.ok) throw httpUsageError(res.status, 'sign in again in Gemini CLI');
-    return res.json();
-  };
-  let plan = null;
-  let projectId = project;
-  if (!projectId) {
-    const loaded = await post('loadCodeAssist', {
-      metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' },
-    });
-    const found = loaded?.cloudaicompanionProject;
-    projectId = typeof found === 'string' ? found : typeof found?.id === 'string' ? found.id : null;
-    // A paid tier is the effective subscription, as Gemini CLI reads it.
-    const tier = loaded?.paidTier?.id || loaded?.paidTier?.name ? loaded.paidTier : loaded?.currentTier;
-    plan = tier?.name ?? tier?.id ?? null;
-    if (!projectId) throw new UsageError('Gemini CLI has no Code Assist project yet; finish signing in with gemini first');
-  }
-  const quota = await post('retrieveUserQuota', { project: projectId });
-  const windows = [];
-  for (const bucket of Array.isArray(quota?.buckets) ? quota.buckets : []) {
-    if (!bucket?.modelId || typeof bucket.remainingFraction !== 'number') continue;
-    const used = clampPercent((1 - bucket.remainingFraction) * 100);
-    if (used !== null) windows.push({ label: String(bucket.modelId).slice(0, 40), usedPercent: used, resetsAt: toIso(bucket.resetTime) });
-  }
-  return { plan, windows, project: projectId, token };
-}
-
 // ---- any command that prints JSON ------------------------------------------
 
 export async function commandUsage({ command, args = [] }, env, platform = process.platform) {
@@ -532,9 +302,8 @@ export class UsageMonitor {
     this.platform = platform;
     this.fetchImpl = fetchImpl;
     this.ttlMs = ttlMs;
-    this.readers = { claude: readClaudeCredentials, codex: readCodexCredentials, gemini: readGeminiCredentials, ...readers };
+    this.readers = { claude: readClaudeCredentials, codex: readCodexCredentials, ...readers };
     this.cache = new Map();
-    this.gemini = new Map();
   }
 
   /** Snapshots for every account of every provider that has a usage source. */
@@ -553,7 +322,7 @@ export class UsageMonitor {
     const now = Date.now();
     if (entry?.inflight) return entry.inflight;
     if (entry && now - entry.at < entry.ttl) return Promise.resolve(entry.snapshot);
-    const inflight = this._fetch(provider, account, key).then((snapshot) => {
+    const inflight = this._fetch(provider, account).then((snapshot) => {
       const ttl = snapshot.rateLimited ? RATE_LIMITED_TTL_MS : this.ttlMs;
       this.cache.set(key, { snapshot, at: Date.now(), ttl });
       return snapshot;
@@ -562,7 +331,7 @@ export class UsageMonitor {
     return inflight;
   }
 
-  async _fetch(provider, account, key) {
+  async _fetch(provider, account) {
     const base = { providerId: provider.id, accountId: account.id, plan: null, windows: [], credits: null, signedIn: null, fetchedAt: new Date().toISOString(), error: null };
     const env = { ...this.env, ...provider.env, ...account.env };
     let signedIn = null;
@@ -580,30 +349,6 @@ export class UsageMonitor {
         const creds = await this.readers.codex({ file: codexAuthFile(env) });
         signedIn = true;
         result = await fetchCodexUsage({ ...creds, fetchImpl: this.fetchImpl });
-      } else if (provider.usage === 'gemini') {
-        const creds = await this.readers.gemini({
-          file: geminiCredentialsFile(env),
-          keychainFile: geminiKeychainFile(env),
-          platform: this.platform,
-          ...geminiStorageMode(env),
-        });
-        signedIn = true;
-        // The refreshed token, project and plan belong to one sign-in; a new
-        // sign-in (another account, or the same one again) starts over.
-        const signIn = creds.refreshToken || creds.accessToken;
-        const cached = this.gemini.get(key);
-        const known = cached?.signIn === signIn ? cached : {};
-        const fresh = known.token && known.token.expiresAt > Date.now() + 60000 ? known.token : null;
-        const { plan, windows, project, token } = await fetchGeminiUsage({
-          ...creds,
-          client: creds.client || geminiOAuthClientFromInstall(this.registry.resolve(provider)),
-          ...(fresh || {}),
-          project: env.GOOGLE_CLOUD_PROJECT || env.GOOGLE_CLOUD_PROJECT_ID || known.project || null,
-          version: this.registry.versions.get(provider.id)?.installed,
-          fetchImpl: this.fetchImpl,
-        });
-        this.gemini.set(key, { signIn, project, token, plan: plan ?? known.plan ?? null });
-        result = { plan: plan ?? known.plan ?? null, windows };
       } else {
         result = await commandUsage(provider.usage, env, this.platform);
       }

package/src/report/hooks.mjs

@@ -1,21 +1,16 @@
 // Translate a coding tool's hook event into Agent Guild reports.
 //
-// Claude Code, Codex CLI, Gemini CLI and Grok Build all run hook commands
-// with one JSON event on stdin. They spell the event name and the sub-agent
-// and model fields differently, so every spelling is accepted here.
+// Claude Code, Codex CLI, Antigravity CLI and Grok Build all run hook
+// commands with one JSON event on stdin. They spell the event name and the
+// sub-agent and model fields differently, so every spelling is accepted here.
 //
 // Sub-agents come from:
 // - SubagentStart / SubagentStop (Claude Code, Codex CLI, Grok Build).
-// - A tool call that runs a sub-agent: Gemini CLI's `invoke_agent`
-//   (BeforeTool / AfterTool), which returns when the agent is finished, and
-//   Claude Code's "Agent" tool (formerly "Task") on PreToolUse / PostToolUse
+// - Claude Code's "Agent" tool (formerly "Task") on PreToolUse / PostToolUse
 //   for versions without the sub-agent events. A launch marked as background
 //   returns immediately, so its PostToolUse says nothing about when the
 //   agent finishes; those launches are skipped. Configure one style, not
-//   both, or each sub-agent appears twice. Gemini's call is a foreground
-//   agent: the parent waits for it, and when its end event never comes (a
-//   cancelled or denied call) it is closed at the next turn boundary of the
-//   main session.
+//   both, or each sub-agent appears twice.
 // - Codex CLI ends every turn of a sub-agent with SubagentStop; a follow-up
 //   turn of the same agent starts with a UserPromptSubmit inside it, or,
 //   with Codex's multi_agent_v2 tools, straight with tool calls, which
@@ -27,11 +22,11 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
 
-const SUBAGENT_TOOLS = new Set(['Task', 'Agent', 'invoke_agent']);
-const SHELL_TOOLS = new Set(['Bash', 'PowerShell', 'run_shell_command', 'run_terminal_command']);
-const TOOL_START_EVENTS = new Set(['PreToolUse', 'BeforeTool']);
-const TOOL_END_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure', 'AfterTool']);
-const TURN_BOUNDARY_EVENTS = new Set(['BeforeAgent', 'AfterAgent', 'UserPromptSubmit', 'Stop', 'Interrupt']);
+const SUBAGENT_TOOLS = new Set(['Task', 'Agent']);
+const SHELL_TOOLS = new Set(['Bash', 'PowerShell', 'run_terminal_command']);
+const TOOL_START_EVENTS = new Set(['PreToolUse']);
+const TOOL_END_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
+const TURN_BOUNDARY_EVENTS = new Set(['UserPromptSubmit', 'Stop', 'Interrupt']);
 const MAX_DETAIL = 200;
 
 const FINISHED_TASKS = new Set(['completed', 'failed', 'killed']);
@@ -44,32 +39,21 @@ function commandHash(command) {
   return crypto.createHash('sha256').update(command.replace(/\s+/g, ' ').trim()).digest('hex').slice(0, 32);
 }
 
-function geminiBackgroundPids(response) {
-  const content = response?.llmContent;
-  const body = typeof content === 'string' ? content
-    : Array.isArray(content) ? content.map((part) => (typeof part === 'string' ? part : part?.text || '')).join('\n') : '';
-  const own = body.match(/Command is running in background\. PID: (\d+)/) || body.match(/moved to background \(PID: (\d+)\)/);
-  if (own) return [Number(own[1])];
-  const left = body.match(/Background PIDs: (\d+(?:, \d+)*)/);
-  return left ? left[1].split(', ').map(Number) : [];
-}
-
 function shellReport(event, input, subagentId) {
   const toolInput = input.tool_input || input.toolInput || {};
   const id = text(input.tool_use_id, input.toolUseId);
-  const ref = id ? { key: id.slice(0, 128) } : { bucket: crypto.createHash('sha256').update(JSON.stringify(toolInput)).digest('hex').slice(0, 32) };
   const agent = subagentId ? { agentId: `hook-${subagentId}` } : {};
   const match = typeof toolInput.command === 'string' ? { match: commandHash(toolInput.command) } : {};
   // Codex CLI (its events carry turn_id) keeps a command running past its turn, and reports no end for one it refused.
   const codex = Boolean(text(input.turn_id));
   if (event === 'PermissionRequest') return { shell: codex ? 'asked' : 'waiting', ...agent, ...match };
-  if (TOOL_START_EVENTS.has(event)) return { shell: 'start', ...ref, ...agent, ...match, ...(codex ? { persist: true } : {}) };
+  if (!id) return null;
+  const key = id.slice(0, 128);
+  if (TOOL_START_EVENTS.has(event)) return { shell: 'start', key, ...agent, ...match, ...(codex ? { persist: true } : {}) };
   const response = input.tool_response ?? input.toolResponse;
   const task = text(response?.backgroundTaskId);
-  if (task) return { shell: 'background', ...ref, task: task.slice(0, 128), ...(response.backgroundEndsWithFinalResponse === true ? { endsWithAgent: true } : {}) };
-  const pids = geminiBackgroundPids(response);
-  if (pids.length) return { shell: 'background', ...ref, pids };
-  return { shell: 'end', ...ref };
+  if (task) return { shell: 'background', key, task: task.slice(0, 128), ...(response.backgroundEndsWithFinalResponse === true ? { endsWithAgent: true } : {}) };
+  return { shell: 'end', key };
 }
 
 // Claude Code reports a background task ending as a prompt of <task-notification> blocks.
@@ -145,7 +129,8 @@ export function hookToReports(input) {
 
   const toolName = text(input.tool_name, input.toolName);
   const toolEvent = TOOL_START_EVENTS.has(event) || TOOL_END_EVENTS.has(event);
-  if ((toolEvent || event === 'PermissionRequest') && SHELL_TOOLS.has(toolName)) reports.push(shellReport(event, input, subagentId));
+  const shell = (toolEvent || event === 'PermissionRequest') && SHELL_TOOLS.has(toolName) ? shellReport(event, input, subagentId) : null;
+  if (shell) reports.push(shell);
   if (event === 'PostToolUse' && toolName === 'TaskStop') {
     const toolInput = input.tool_input || input.toolInput || {};
     const task = text(toolInput.task_id, toolInput.shell_id);
@@ -153,20 +138,14 @@ export function hookToReports(input) {
   }
   if (toolEvent && SUBAGENT_TOOLS.has(toolName)) {
     const toolInput = input.tool_input || input.toolInput || {};
-    if (toolInput.run_in_background !== true) {
-      // tool_use_id links the start and end events; fall back to hashing the
-      // identical tool_input both events carry (Gemini CLI sends no id).
-      const key = text(input.tool_use_id, input.toolUseId) ||
-        crypto.createHash('sha1').update(JSON.stringify(toolInput)).digest('hex').slice(0, 16);
+    const key = text(input.tool_use_id, input.toolUseId);
+    if (key && toolInput.run_in_background !== true) {
       reports.push({
         agentId: `hook-task-${key}`,
         name: text(toolInput.subagent_type, toolInput.agent_name) || 'subagent',
         kind: 'subagent',
         detail: (text(toolInput.description, toolInput.prompt) || '').slice(0, MAX_DETAIL),
         status: TOOL_START_EVENTS.has(event) ? 'working' : 'done',
-        // Gemini CLI's call returns when the agent is finished, so the
-        // parent waits: a model reported meanwhile is the sub-agent's.
-        foreground: toolName === 'invoke_agent',
       });
     }
   }
@@ -183,26 +162,26 @@ export function hookToReports(input) {
   // agent_id, Grok Build by subagentType); its model is not the session's.
   const insideSubagent = Boolean(subagentId || text(input.subagent_type, input.subagentType));
 
-  // Gemini CLI skips AfterTool for an invoke_agent call that was cancelled
-  // or denied. A turn boundary of the main session (BeforeAgent and
-  // AfterAgent in Gemini CLI; a main-thread prompt or Stop elsewhere) cannot
-  // happen while the parent waits for a foreground agent, so one still
-  // working then has been orphaned.
   if (event === 'Stop' && Array.isArray(input.background_tasks)) reports.push(runningShells(input.background_tasks));
   if (!insideSubagent && TURN_BOUNDARY_EVENTS.has(event)) reports.push({ finishForeground: true });
 
   const model = insideSubagent || toolEvent ? null : event === 'PostModelSwitch'
     ? text(input.to_model)
-    : text(input.model, input.modelId, input.llm_request?.model);
+    : text(input.model, input.modelId, input.modelName);
   if (model) reports.push({ model });
 
   if (!insideSubagent && event === 'SessionStart') reports.push({ hello: true });
 
-  const toolSessionId = insideSubagent ? null : text(input.session_id, input.sessionId);
-  if (toolSessionId && (event === 'SessionStart' || event === 'BeforeAgent')) reports.push({ toolSessionId });
+  const toolSessionId = insideSubagent ? null : text(input.session_id, input.sessionId, input.conversationId);
+  if (toolSessionId && (event === 'SessionStart' || event === 'PreInvocation')) reports.push({ toolSessionId });
   return reports;
 }
 
+/** Whether an Antigravity CLI conversation starts with the user's own request; a sub-agent's starts with its parent's message. */
+export function antigravityUserConversation(firstRecord) {
+  return firstRecord?.type === 'USER_INPUT' && firstRecord.source === 'USER_EXPLICIT';
+}
+
 /** Model report from the JSON Claude Code feeds to a status line command. */
 export function claudeStatuslineToReport(input) {
   const id = input?.model?.id;

package/web/app.js

@@ -493,22 +493,20 @@ function renderAccounts(card, provider) {
 
 function renderReportingSetup(card, provider) {
   const row = card.querySelector('.reporting-row');
-  const account = selectedAccount(provider);
-  row.hidden = !provider.available || typeof account.reportingEnabled !== 'boolean';
+  row.hidden = !provider.available || typeof provider.reportingEnabled !== 'boolean';
   if (row.hidden) return;
-  const on = account.reportingEnabled;
-  const whose = (provider.accounts || []).length > 1 ? ` for the ${account.label} account` : '';
+  const on = provider.reportingEnabled;
   row.querySelector('.reporting-text').textContent = `Agent reporting ${on ? 'on' : 'off'}`;
   const button = row.querySelector('.reporting-toggle');
   button.textContent = on ? 'Turn off' : 'Turn on';
   button.title = on
-    ? `Remove the Agent Guild extension from ${provider.tool}${whose}. New sessions stop reporting sub-agents.`
-    : `Link the Agent Guild extension into ${provider.tool}${whose} with "${provider.command} extensions link", so new sessions show their sub-agents. It does nothing in sessions started outside Agent Guild.`;
+    ? `Remove the Agent Guild plugin from ${provider.tool}. New sessions stop reporting their model.`
+    : `Install the Agent Guild plugin into ${provider.tool} with "${provider.command} plugin install", so new sessions show their model and can be resumed. It does nothing in sessions started outside Agent Guild.`;
   button.onclick = async () => {
     button.disabled = true;
     try {
-      await api('POST', `/providers/${provider.id}/reporting`, { account: account.id, enabled: !on });
-      toast(on ? `Agent reporting is off for ${provider.tool}${whose}.` : `Agent reporting is on for ${provider.tool}${whose}. It applies to new sessions.`);
+      await api('POST', `/providers/${provider.id}/reporting`, { enabled: !on });
+      toast(on ? `Agent reporting is off for ${provider.tool}.` : `Agent reporting is on for ${provider.tool}. It applies to new sessions.`);
     } catch (err) {
       if (err instanceof AuthError) return showAuth(err.message);
       toast(err.message, 10000);
@@ -1694,7 +1692,7 @@ async function installProvider(provider, card, { force = false } = {}) {
 
 /**
  * Start a session. A resumed session starts in the folder its transcript
- * names, since Claude Code and Gemini CLI only find a session from there;
+ * names, since Claude Code only finds a session from there;
  * when that folder is gone, the working folder is used instead.
  */
 async function startSession(provider, card, { resume, cwd, account = selectedAccount(provider).id } = {}) {

package/examples/gemini-settings.json

@@ -1,61 +0,0 @@
-{
-  "hooks": {
-    "BeforeTool": [
-      {
-        "matcher": "invoke_agent",
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild agent start",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "AfterTool": [
-      {
-        "matcher": "invoke_agent",
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild agent stop",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "BeforeAgent": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild turn start",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "AfterAgent": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild turn end",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ],
-    "BeforeModel": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "name": "Agent Guild model",
-            "command": "agent-guild-report --hook"
-          }
-        ]
-      }
-    ]
-  }
-}