@oddessentials/agent-guild 0.11.0 → 0.12.1

package/src/manager/session-hooks.mjs

@@ -5,8 +5,8 @@ import { spawn } from 'node:child_process';
 import { buildSpawnSpec, runSpec, killWindowsTree } from './command-resolver.mjs';
 
 export const REPORT_COMMAND = 'agent-guild-report --hook';
-export const EXTENSION_NAME = 'agent-guild';
-const MANIFEST_DESCRIPTION = 'Reports sub-agents to the Agent Guild session they run in.';
+export const PLUGIN_NAME = 'agent-guild';
+const MANIFEST_DESCRIPTION = 'Reports to the Agent Guild session it runs in.';
 const PROBE_TIMEOUT_MS = 20000;
 const PROBE_RETRY_MS = 5 * 60 * 1000;
 
@@ -28,35 +28,32 @@ const claudeHooks = () => Object.fromEntries(CLAUDE_EVENTS.map((event) => [event
 }]]));
 const GROK_EVENTS = ['SessionStart', 'SubagentStart', 'SubagentStop', 'StopCancelled', 'SessionEnd', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'Stop'];
 
-// Gemini's extension stays linked outside Agent Guild, where the launchers are not on PATH.
-export function geminiCommand(shimDir, platform = process.platform) {
-  if (!shimDir) return REPORT_COMMAND;
-  if (platform === 'win32') return `& '${path.win32.join(shimDir, 'agent-guild-report.cmd').replace(/'/g, "''")}' --hook`;
-  return `'${path.posix.join(shimDir, 'agent-guild-report').replace(/'/g, `'\\''`)}' --hook`;
+// Antigravity CLI loads an installed plugin into every session, also those started outside Agent Guild, and runs
+// its hooks in the plugin's folder, on Windows through cmd /C, which cannot take a quoted path. So the hook is a
+// script in that folder: it reports only inside an Agent Guild Antigravity session, and always prints the JSON object
+// Antigravity reads.
+function antigravityFiles(manifest, platform) {
+  const script = platform === 'win32'
+    ? ['@echo off', `if "%AGENT_GUILD_REPORTING%"=="antigravity" call ${REPORT_COMMAND} --event %1`, 'echo {}', ''].join('\r\n')
+    : ['#!/bin/sh', `if [ "$AGENT_GUILD_REPORTING" = antigravity ] && command -v agent-guild-report >/dev/null 2>&1; then ${REPORT_COMMAND} --event "$1"; else cat >/dev/null; fi`, "echo '{}'", ''].join('\n');
+  const name = platform === 'win32' ? 'agent-guild-hook.cmd' : 'agent-guild-hook.sh';
+  const command = platform === 'win32' ? `.\\${name} PreInvocation` : `sh ${name} PreInvocation`;
+  return {
+    'plugin.json': `${JSON.stringify(manifest, null, 2)}\n`,
+    'hooks.json': `${JSON.stringify({ [PLUGIN_NAME]: { PreInvocation: [{ type: 'command', command, timeout: 10 }] } }, null, 2)}\n`,
+    [name]: script,
+  };
 }
 
-export function bundleFiles(version, { shimDir = null, platform = process.platform } = {}) {
+export function bundleFiles(version, { platform = process.platform } = {}) {
   const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
-  const manifest = { name: EXTENSION_NAME, version, description: MANIFEST_DESCRIPTION };
-  const gemini = (name, matcher) => ({ ...(matcher ? { matcher } : {}), hooks: [handler({ name: `Agent Guild ${name}`, command: geminiCommand(shimDir, platform) })] });
+  const manifest = { name: PLUGIN_NAME, version, description: MANIFEST_DESCRIPTION };
   return {
     claude: {
       '.claude-plugin/plugin.json': json(manifest),
       'hooks/hooks.json': json({ hooks: claudeHooks() }),
     },
-    gemini: {
-      'gemini-extension.json': json(manifest),
-      'hooks/hooks.json': json({
-        hooks: {
-          SessionStart: [gemini('session start')],
-          BeforeTool: [gemini('agent start', 'invoke_agent'), gemini('shell start', 'run_shell_command')],
-          AfterTool: [gemini('agent stop', 'invoke_agent'), gemini('shell stop', 'run_shell_command')],
-          BeforeAgent: [gemini('turn start')],
-          AfterAgent: [gemini('turn end')],
-          BeforeModel: [gemini('model')],
-        },
-      }),
-    },
+    antigravity: antigravityFiles({ name: PLUGIN_NAME, description: MANIFEST_DESCRIPTION }, platform),
     grok: {
       '.grok-plugin/plugin.json': json(manifest),
       'hooks/hooks.json': json({
@@ -188,50 +185,51 @@ export function helpLists(text, flag) {
   return new RegExp(`^\\s+(?:-\\w, )?${flag.replace(/[-]/g, '\\-')}\\b`, 'm').test(text);
 }
 
-export function geminiHome(env = {}) {
-  return env.GEMINI_CLI_HOME || os.homedir();
-}
+const geminiHome = (env, platform) => path.join((platform === 'win32' ? env.USERPROFILE : env.HOME) || os.homedir(), '.gemini');
 
-function geminiRecord(home) {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(home, '.gemini', 'extensions', EXTENSION_NAME, '.gemini-extension-install.json'), 'utf8'));
-  } catch {
-    return null;
-  }
+/** Where `agy plugin install` copies the plugin and where Antigravity CLI loads it from. */
+export function antigravityPluginDir(env = {}, platform = process.platform) {
+  return path.join(geminiHome(env, platform), 'config', 'plugins', PLUGIN_NAME);
 }
 
-export function geminiLinked(home, bundle) {
-  const record = geminiRecord(home);
-  return record?.type === 'link' && typeof record.source === 'string' && path.resolve(record.source) === path.resolve(bundle);
+/** The shared Antigravity settings, where `agy plugin disable` turns a plugin off. */
+export function antigravityConfigFile(env = {}, platform = process.platform) {
+  return path.join(geminiHome(env, platform), 'config', 'config.json');
 }
 
-export function geminiStaleLink(home, bundle) {
-  const record = geminiRecord(home);
-  if (!record || geminiLinked(home, bundle)) return false;
-  if (record.type !== 'link' || typeof record.source !== 'string') return false;
+/** True unless the settings turn the plugin off or cannot be read; no settings file means every plugin is on. */
+export function antigravityPluginEnabled(configFile) {
+  let config;
   try {
-    return JSON.parse(fs.readFileSync(path.join(record.source, 'gemini-extension.json'), 'utf8')).description === MANIFEST_DESCRIPTION;
+    config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
   } catch (err) {
     return err.code === 'ENOENT';
   }
+  if (!config || typeof config !== 'object') return false;
+  return config.plugins?.[PLUGIN_NAME]?.enabled !== false;
 }
 
-// Gemini's uninstall finds only extensions that load, so a link to a folder without its manifest is removed here, as uninstall would.
-function removeDanglingLink(home) {
-  const extensions = path.join(home, '.gemini', 'extensions');
-  fs.rmSync(path.join(extensions, EXTENSION_NAME), { recursive: true, force: true });
-  const enablement = path.join(extensions, 'extension-enablement.json');
-  let config;
-  try { config = JSON.parse(fs.readFileSync(enablement, 'utf8')); } catch { return; }
-  if (!config || typeof config !== 'object' || !(EXTENSION_NAME in config)) return;
-  delete config[EXTENSION_NAME];
-  fs.writeFileSync(enablement, JSON.stringify(config, null, 2));
+function readOr(file, fallback) {
+  try { return fs.readFileSync(file, 'utf8'); } catch { return fallback; }
+}
+
+/** "current" when the installed copy matches the bundle, "stale" when it is an older one of ours, "other" or null. */
+export function antigravityInstalled(pluginDir, bundle) {
+  const manifest = readOr(path.join(pluginDir, 'plugin.json'), null);
+  if (manifest === null) return null;
+  let description = null;
+  try { description = JSON.parse(manifest)?.description; } catch { /* not ours */ }
+  if (description !== MANIFEST_DESCRIPTION) return 'other';
+  let names = [];
+  try { names = fs.readdirSync(bundle); } catch { return 'stale'; }
+  const same = names.every((name) => readOr(path.join(pluginDir, name), null) === readOr(path.join(bundle, name), ''));
+  return same ? 'current' : 'stale';
 }
 
 const pending = (tool, when) => ({ state: 'pending', reason: `Agent Guild added its reporting hooks to this ${tool} session. They report once ${tool} ${when}.` });
 
 export class SessionHooks {
-  constructor({ registry, dir, version, shimDir = null, probeTimeoutMs = PROBE_TIMEOUT_MS, probeRetryMs = PROBE_RETRY_MS }) {
+  constructor({ registry, dir, version, probeTimeoutMs = PROBE_TIMEOUT_MS, probeRetryMs = PROBE_RETRY_MS }) {
     this.registry = registry;
     this.probeTimeoutMs = probeTimeoutMs;
     this.probeRetryMs = probeRetryMs;
@@ -240,7 +238,7 @@ export class SessionHooks {
     this.probes = new Map();
     if (dir) {
       try {
-        this.bundles = writeBundles(dir, version, { shimDir, platform: registry.platform });
+        this.bundles = writeBundles(dir, version, { platform: registry.platform });
       } catch (err) {
         console.warn(`[reporting] could not write the reporting hooks to ${dir}: ${err.message}`);
       }
@@ -278,15 +276,15 @@ export class SessionHooks {
     return entry.promise;
   }
 
-  async launch(provider, account) {
+  async launch(provider) {
     const mode = provider.reporting;
     if (!mode) return { args: [], reporting: null };
     const tool = provider.tool;
     if (!this.bundles) {
       return { args: [], reporting: { state: 'unavailable', reason: `Agent Guild could not write its reporting hooks, so ${tool} cannot report agents.` } };
     }
-    if (mode === 'gemini') {
-      if (this.enabled(provider, account)) return { args: [], reporting: pending(tool, 'starts its session') };
+    if (mode === 'antigravity') {
+      if (this.enabled(provider)) return { args: [], reporting: pending(tool, 'runs its first prompt') };
       return { args: [], reporting: { state: 'setup_required', reason: `Agent reporting is off for ${tool}. Turn it on from the ${tool} card; it applies to new sessions.` } };
     }
     const probe = await this._probe(provider);
@@ -308,42 +306,45 @@ export class SessionHooks {
     };
   }
 
-  enabled(provider, account) {
-    if (provider.reporting !== 'gemini' || !this.bundles) return null;
-    return geminiLinked(geminiHome({ ...this.registry.env, ...provider.env, ...account?.env }), this.bundles.gemini);
+  enabled(provider) {
+    if (provider.reporting !== 'antigravity' || !this.bundles) return null;
+    return this._installed(provider) === 'current' && this._pluginEnabled(provider);
+  }
+
+  _installed(provider) {
+    return antigravityInstalled(antigravityPluginDir({ ...this.registry.env, ...provider.env }, this.registry.platform), this.bundles.antigravity);
   }
 
-  async setEnabled(provider, account, enabled) {
-    if (provider.reporting !== 'gemini') throw Object.assign(new Error(`${provider.tool} needs no setup for agent reporting`), { status: 400, code: 'not_applicable' });
+  _pluginEnabled(provider) {
+    return antigravityPluginEnabled(antigravityConfigFile({ ...this.registry.env, ...provider.env }, this.registry.platform));
+  }
+
+  async setEnabled(provider, enabled) {
+    if (provider.reporting !== 'antigravity') throw Object.assign(new Error(`${provider.tool} needs no setup for agent reporting`), { status: 400, code: 'not_applicable' });
     if (!this.bundles) throw Object.assign(new Error('Agent Guild could not write its reporting hooks'), { status: 500, code: 'reporting_unavailable' });
     const resolved = this.registry.resolve(provider);
     if (!resolved) throw Object.assign(new Error(`${provider.tool} is not installed`), { status: 409, code: 'provider_unavailable' });
-    const env = { ...this.registry.env, ...provider.env, ...account?.env };
-    const home = geminiHome(env);
-    const stale = geminiStaleLink(home, this.bundles.gemini);
-    if (enabled === this.enabled(provider, account) && !stale) return enabled;
-    if (enabled && !stale && geminiRecord(home)) {
-      throw Object.assign(new Error(`${provider.tool} already has another extension named "${EXTENSION_NAME}". Remove it with "${provider.command} extensions uninstall ${EXTENSION_NAME}" to turn on agent reporting.`), { status: 409, code: 'extension_conflict' });
+    const installed = this._installed(provider);
+    if (enabled ? installed === 'current' && this._pluginEnabled(provider) : !installed) return enabled;
+    if (installed === 'other') {
+      if (!enabled) return false;
+      throw Object.assign(new Error(`${provider.tool} already has another plugin named "${PLUGIN_NAME}". Remove it with "${provider.command} plugin uninstall ${PLUGIN_NAME}" to turn on agent reporting.`), { status: 409, code: 'plugin_conflict' });
     }
+    const env = { ...this.registry.env, ...provider.env };
     const run = async (args, what) => {
       try {
-        const commandEnv = { ...env, GEMINI_CLI_TRUST_WORKSPACE: 'true' };
-        await runSpec(buildSpawnSpec(resolved, args, commandEnv, this.registry.platform), { env: commandEnv, timeoutMs: 60000, cwd: this.dir });
+        await runSpec(buildSpawnSpec(resolved, args, env, this.registry.platform), { env, timeoutMs: 60000, cwd: this.dir });
       } catch (err) {
         const detail = `${err.stderr || ''}\n${err.stdout || ''}`.trim().split('\n').filter(Boolean).pop() || err.message;
-        throw Object.assign(new Error(`${provider.tool} could not ${what} the Agent Guild extension: ${detail}`), { status: 502, code: 'reporting_setup_failed' });
+        throw Object.assign(new Error(`${provider.tool} could not ${what} the Agent Guild plugin: ${detail}`), { status: 502, code: 'reporting_setup_failed' });
       }
     };
-    const record = geminiRecord(home);
-    if (stale && !fs.existsSync(path.join(record.source, 'gemini-extension.json'))) {
-      removeDanglingLink(home);
-    } else if (stale || !enabled) {
-      await run(['extensions', 'uninstall', EXTENSION_NAME], 'remove');
-    }
-    if (enabled) await run(['extensions', 'link', this.bundles.gemini, '--consent'], 'link');
-    const now = this.enabled(provider, account);
+    if (installed && (!enabled || installed === 'stale')) await run(['plugin', 'uninstall', PLUGIN_NAME], 'remove');
+    if (enabled && installed !== 'current') await run(['plugin', 'install', this.bundles.antigravity], 'install');
+    if (enabled && !this._pluginEnabled(provider)) await run(['plugin', 'enable', PLUGIN_NAME], 'turn on');
+    const now = this.enabled(provider);
     if (now !== enabled) {
-      throw Object.assign(new Error(`${provider.tool} reported success, but the Agent Guild extension is ${now ? 'still linked' : 'not linked'}`), { status: 502, code: 'reporting_setup_failed' });
+      throw Object.assign(new Error(`${provider.tool} reported success, but the Agent Guild plugin is ${now ? 'still on' : 'not on'}`), { status: 502, code: 'reporting_setup_failed' });
     }
     return now;
   }

package/src/manager/session-manager.mjs

@@ -54,7 +54,7 @@ export class SessionManager extends EventEmitter {
    * @param {import('./self-update.mjs').SelfUpdate|null} [opts.selfUpdate]  the manager's own upgrade
    * @param {import('./github.mjs').GitHub|null} [opts.github]
    */
-  constructor({ registry, baseEnv, getApiUrl, sessionDefaults = {}, shimDir = null, selfUpdate = null, github = null, sessionHooks = null, reportTokenDir = null }) {
+  constructor({ registry, baseEnv, getApiUrl, sessionDefaults = {}, shimDir = null, selfUpdate = null, github = null, sessionHooks = null }) {
     super();
     this.registry = registry;
     this.baseEnv = baseEnv;
@@ -64,7 +64,6 @@ export class SessionManager extends EventEmitter {
     this.selfUpdate = selfUpdate;
     this.github = github;
     this.sessionHooks = sessionHooks;
-    this.reportTokenDir = reportTokenDir;
     this.sessions = new Map();
     /** Removed sessions whose process has not exited yet. */
     this.exiting = new Set();
@@ -104,7 +103,7 @@ export class SessionManager extends EventEmitter {
     const resumeId = cleanResumeId(resume);
     const workDir = this.resolveCwd(cwd);
     const signIn = this.registry.account(provider, account);
-    const hooks = this.sessionHooks ? await this.sessionHooks.launch(provider, signIn) : { args: [], reporting: null };
+    const hooks = this.sessionHooks ? await this.sessionHooks.launch(provider) : { args: [], reporting: null };
     const spawnSpec = this.registry.spawnSpec(provider, args || [], resumeId, hooks.args);
     this.prepareAccount(provider, signIn, { hooksSupplied: hooks.args.length > 0 });
     const sessionName = cleanName(name) || (provider.accounts.length > 1 ? `${provider.tool} · ${signIn.label}` : null);
@@ -236,7 +235,6 @@ export class SessionManager extends EventEmitter {
     }
     const id = newId();
     const reportToken = crypto.randomBytes(16).toString('hex');
-    const reportFile = this._writeReportToken(id, reportToken);
 
     // The tool's hooks run `agent-guild-report` by name, so the launchers
     // go first on PATH, after any provider PATH override.
@@ -245,9 +243,9 @@ export class SessionManager extends EventEmitter {
       COLORTERM: 'truecolor',
       AGENT_GUILD_SESSION_ID: id,
       AGENT_GUILD_PROVIDER: provider.id,
+      AGENT_GUILD_REPORTING: provider.reporting || '',
       AGENT_GUILD_URL: this.getApiUrl(),
       AGENT_GUILD_REPORT_TOKEN: reportToken,
-      AGENT_GUILD_REPORT_FILE: reportFile,
       AGENT_GUILD_NODE: process.execPath,
     }]), this.shimDir);
     // The tool runs in its own terminal, not in the terminal or multiplexer
@@ -278,10 +276,8 @@ export class SessionManager extends EventEmitter {
         reporting,
       });
     } catch (err) {
-      this._removeReportToken(reportFile);
       throw httpError(500, `could not start ${provider.tool}: ${err.message}`, 'spawn_failed');
     }
-    session.exited.then(() => this._removeReportToken(reportFile));
 
     session.on('changed', () => {
       if (this.sessions.has(id)) this.emit('event', { type: 'session.updated', session: session.toJSON() });
@@ -303,32 +299,6 @@ export class SessionManager extends EventEmitter {
     return session;
   }
 
-  // Only once this manager owns the port, so a second one that fails to start leaves the running one's files.
-  sweepReportTokens() {
-    if (!this.reportTokenDir) return;
-    const live = new Set(this.sessions.keys());
-    let names = [];
-    try { names = fs.readdirSync(this.reportTokenDir); } catch { return; }
-    for (const name of names) if (!live.has(name)) fs.rm(path.join(this.reportTokenDir, name), { force: true }, () => {});
-  }
-
-  _writeReportToken(id, token) {
-    if (!this.reportTokenDir) return null;
-    try {
-      fs.mkdirSync(this.reportTokenDir, { recursive: true, mode: 0o700 });
-      const file = path.join(this.reportTokenDir, id);
-      fs.writeFileSync(file, token, { mode: 0o600, flag: 'wx' });
-      return file;
-    } catch (err) {
-      console.warn(`[manager] could not write the report token file for session ${id}: ${err.message}`);
-      return null;
-    }
-  }
-
-  _removeReportToken(file) {
-    if (file) fs.rm(file, { force: true }, () => {});
-  }
-
   /** Remove a session from the list, ending its process if still running. */
   remove(id) {
     const session = this.get(id);

package/src/manager/session.mjs

@@ -22,18 +22,8 @@ const MAX_TOOL_SESSION_ID = 200;
 const REPORTING_STATES = new Set(['pending', 'active', 'unavailable', 'setup_required', 'unsupported']);
 const SHELL_EVENTS = new Set(['start', 'waiting', 'asked', 'background', 'end', 'running', 'reset']);
 const MAX_SHELLS = 256;
-const MAX_SHELL_PIDS = 16;
 const MAX_ENDED_TASKS = 256;
 
-function processExists(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === 'EPERM';
-  }
-}
-
 /**
  * Colours reported to programs that query them (OSC 10/11/12), matching the
  * web page's terminal theme. Tools use these to choose light or dark output.
@@ -99,11 +89,9 @@ export class Session extends EventEmitter {
     this.reporting = REPORTING_STATES.has(opts.reporting?.state) ? { state: opts.reporting.state, reason: opts.reporting.reason ?? null } : null;
     this._reportingTimer = null;
     this.shellDisplayDelayMs = opts.shellDisplayDelayMs ?? 600;
-    this.shellPidCheckMs = opts.shellPidCheckMs ?? 2000;
     this.shells = new Map();
     this._shellSeq = 0;
     this._endedTasks = new Set();
-    this._pidTimer = null;
     this.createdAt = new Date().toISOString();
     this.exitedAt = null;
     this.status = 'running';
@@ -381,11 +369,6 @@ export class Session extends EventEmitter {
     if (this.status !== 'running') throw Object.assign(new Error('session has exited'), { status: 409 });
     if (source === 'api') this._reportingHeard();
     if (report.finishForeground === true && report.agentId === undefined) {
-      // The tool is between turns, so no foreground agent can still be
-      // running; one that is never got its end event.
-      for (const agent of [...this.agents.values()]) {
-        if (agent.foreground && agent.status === 'working') this.reportAgent({ agentId: agent.id, status: 'done' }, source);
-      }
       this._endForegroundShells(null);
       return null;
     }
@@ -402,11 +385,6 @@ export class Session extends EventEmitter {
     }
     const now = new Date().toISOString();
     const existing = this.agents.get(id);
-    if (!existing && status === 'done' && report.foreground === true) {
-      // Gemini CLI's invoke_agent is paired by its input, which a BeforeTool hook may rewrite before AfterTool.
-      const working = [...this.agents.values()].filter((agent) => agent.foreground && agent.status === 'working');
-      return working.length === 1 ? this.reportAgent({ agentId: working[0].id, status: 'done' }, source) : null;
-    }
     if (status === 'done') this._endForegroundShells(id);
     // A first report that already says done would only flash an icon:
     // Claude Code's internal helpers (prompt suggestions, side questions)
@@ -424,9 +402,6 @@ export class Session extends EventEmitter {
       kind: String(report.kind ?? existing?.kind ?? 'agent').slice(0, 40),
       status,
       detail: report.detail === undefined ? existing?.detail ?? '' : String(report.detail).slice(0, 200),
-      // The parent waits for a foreground agent, so a model reported while
-      // it works belongs to the agent, not to the session.
-      foreground: report.foreground === undefined ? existing?.foreground ?? false : report.foreground === true,
       startedAt: existing?.startedAt ?? now,
       updatedAt: now,
       source,
@@ -488,7 +463,6 @@ export class Session extends EventEmitter {
     if (!SHELL_EVENTS.has(report.shell)) throw badRequest(`shell must be one of ${[...SHELL_EVENTS].join(', ')}`);
     const id = (value) => (typeof value === 'string' && value ? value.slice(0, 128) : null);
     const key = id(report.key);
-    const bucket = !key && typeof report.bucket === 'string' && /^[a-f0-9]{1,64}$/.test(report.bucket) ? report.bucket : null;
     const task = id(report.task);
     const match = typeof report.match === 'string' && /^[a-f0-9]{32}$/.test(report.match) ? report.match : null;
     const agentId = id(report.agentId);
@@ -525,34 +499,23 @@ export class Session extends EventEmitter {
     }
 
     if (report.shell === 'end') {
-      if (!key && !bucket && !task) throw badRequest('a shell end needs a key, a bucket or a task');
+      if (!key && !task) throw badRequest('a shell end needs a key or a task');
       if (task) this._rememberEnded(task);
-      const shell = (key && this._shellBy('key', key)) || (task && this._shellBy('task', task)) || (bucket && this._shellByBucket(bucket));
+      const shell = (key && this._shellBy('key', key)) || (task && this._shellBy('task', task));
       if (shell) this._endShell(shell);
       return null;
     }
 
-    if (!key && !bucket) throw badRequest('a shell report needs a key or a bucket');
+    if (!key) throw badRequest('a shell report needs a key');
     if (report.shell === 'start') {
-      if (!key || !this._shellBy('key', key)) this._addShell({ key, bucket, match, agentId, persist: report.persist === true });
+      if (!this._shellBy('key', key)) this._addShell({ key, match, agentId, persist: report.persist === true });
       return null;
     }
 
-    const pids = Array.isArray(report.pids) ? report.pids.filter((pid) => Number.isInteger(pid) && pid > 0).slice(0, MAX_SHELL_PIDS) : [];
-    if (!task && pids.length === 0) throw badRequest('a background report needs a task or pids');
-    const shell = key ? this._shellBy('key', key) : this._shellByBucket(bucket);
+    if (!task) throw badRequest('a background report needs a task');
+    const shell = this._shellBy('key', key);
     if (!shell) return null;
-    if (task) {
-      Object.assign(shell, { task, endsWithAgent: report.endsWithAgent === true });
-    } else {
-      // Gemini CLI names a pid even for a command that ended at once.
-      shell.pids = pids.filter(processExists);
-      if (shell.pids.length === 0) {
-        this._endShell(shell);
-        return null;
-      }
-      this._checkPids();
-    }
+    Object.assign(shell, { task, endsWithAgent: report.endsWithAgent === true });
     if (shell.waiting) {
       shell.waiting = false;
       this._showAfterDelay(shell);
@@ -566,7 +529,7 @@ export class Session extends EventEmitter {
       return;
     }
     const shell = {
-      id: `shell-${++this._shellSeq}`, key: null, bucket: null, match: null, agentId: null, persist: false, task: null, pids: null,
+      id: `shell-${++this._shellSeq}`, key: null, match: null, agentId: null, persist: false, task: null,
       endsWithAgent: false, waiting: false, asked: false, visible: false, timer: null, ...fields,
     };
     this.shells.set(shell.id, shell);
@@ -587,7 +550,7 @@ export class Session extends EventEmitter {
   }
 
   _foreground(shell) {
-    return shell.task === null && shell.pids === null;
+    return shell.task === null;
   }
 
   _shellBy(field, value) {
@@ -595,30 +558,6 @@ export class Session extends EventEmitter {
     return null;
   }
 
-  // Gemini CLI's calls are paired by their input, which a BeforeTool hook may rewrite before AfterTool.
-  _shellByBucket(bucket) {
-    const open = [...this.shells.values()].filter((shell) => shell.bucket !== null && this._foreground(shell));
-    return open.find((shell) => shell.bucket === bucket) ?? (open.length === 1 ? open[0] : null);
-  }
-
-  _checkPids() {
-    if (this._pidTimer) return;
-    this._pidTimer = setInterval(() => {
-      let watching = false;
-      for (const shell of [...this.shells.values()]) {
-        if (!shell.pids) continue;
-        shell.pids = shell.pids.filter(processExists);
-        if (shell.pids.length) watching = true;
-        else this._endShell(shell);
-      }
-      if (!watching) {
-        clearInterval(this._pidTimer);
-        this._pidTimer = null;
-      }
-    }, this.shellPidCheckMs);
-    this._pidTimer.unref?.();
-  }
-
   // A turn's foreground commands end with it; a background command, or one Codex CLI keeps running, does not.
   _endForegroundShells(agentId) {
     for (const shell of [...this.shells.values()]) {
@@ -642,8 +581,6 @@ export class Session extends EventEmitter {
 
   _clearShells() {
     for (const shell of this.shells.values()) clearTimeout(shell.timer);
-    clearInterval(this._pidTimer);
-    this._pidTimer = null;
     this.shells.clear();
   }
 
@@ -668,10 +605,6 @@ export class Session extends EventEmitter {
     const name = String(report.model ?? '').trim().slice(0, 120);
     if (!name) throw badRequest('model is required');
     const displayName = report.displayName === undefined || report.displayName === null ? null : String(report.displayName).trim().slice(0, 80) || null;
-    // Gemini CLI fires BeforeModel for a sub-agent's requests too, with the
-    // sub-agent's model and nothing to tell them apart. While a foreground
-    // agent works its parent makes no request, so the report is the agent's.
-    if (this._foregroundAgentWorking()) return this.model;
     this.setModel({ name, displayName }, 'report');
     return this.model;
   }
@@ -702,13 +635,6 @@ export class Session extends EventEmitter {
     this._changed();
   }
 
-  _foregroundAgentWorking() {
-    for (const agent of this.agents.values()) {
-      if (agent.foreground && agent.status === 'working') return true;
-    }
-    return false;
-  }
-
   /**
    * Scan shortly after output pauses, and at least every couple of seconds
    * while output keeps coming, so a busy tool still gets scanned.