@phnx-labs/agents-cli 1.20.59 → 1.20.61

package/dist/lib/shims.js

@@ -2024,18 +2024,28 @@ export function releaseAdoptedLauncher(agent, overrides) {
     // records written before this format existed.
     const launcher = lines[1] || getPathShadowingExecutable(agent) || original;
     const shimReal = canonical(path.join(shimsDir, AGENTS[agent].cliCommand));
+    const shimPath = path.resolve(path.join(shimsDir, AGENTS[agent].cliCommand));
     try {
         // Only rewrite the launcher if it currently points at our shim (i.e. we own
         // it). If the user has since replaced it themselves, leave it alone.
         let pointsAtShim = false;
         try {
-            pointsAtShim = fs.lstatSync(launcher).isSymbolicLink()
-                && canonical(launcher) === shimReal;
+            const stat = fs.lstatSync(launcher);
+            if (stat.isSymbolicLink()) {
+                const target = fs.readlinkSync(launcher);
+                const absoluteTarget = path.resolve(path.dirname(launcher), target);
+                pointsAtShim = canonicalOrNull(launcher) === shimReal || absoluteTarget === shimPath;
+            }
         }
         catch { /* launcher gone — recreate below */ }
         if (pointsAtShim || !fs.existsSync(launcher)) {
             try {
-                fs.rmSync(launcher);
+                if (fs.lstatSync(launcher).isSymbolicLink()) {
+                    fs.unlinkSync(launcher);
+                }
+                else {
+                    fs.rmSync(launcher, { force: true });
+                }
             }
             catch { /* may not exist */ }
             fs.symlinkSync(original, launcher);

package/dist/lib/skills.js

@@ -10,7 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
-import { ensureSkillsDir, agentConfigDirName } from './agents.js';
+import { AGENTS, ensureSkillsDir, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { getUserSkillsDir, getSkillsDir as getSystemSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, getTrashSkillsDir } from './state.js';
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
@@ -432,6 +432,19 @@ function versionSkillMatches(agent, version, skillName) {
  */
 export function diffVersionSkills(agent, version) {
     const available = new Set(listAllSkills());
+    // Goose and other native ~/.agents/skills consumers read central storage
+    // directly. They intentionally have no per-version copy to diff, so every
+    // available central skill is already current for every supported version.
+    if (AGENTS[agent].nativeAgentsSkillsDir) {
+        return {
+            agent,
+            version,
+            toAdd: [],
+            toUpdate: [],
+            matched: Array.from(available).sort(),
+            orphans: [],
+        };
+    }
     const installed = new Set(listSkillsInVersionHome(agent, version));
     const toAdd = [];
     const toUpdate = [];

package/dist/lib/staleness/detectors/permissions.js

@@ -110,8 +110,11 @@ function buildGeminiDetector() {
                 return [];
             try {
                 const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                const allowed = settings?.tools?.allowed;
-                if (Array.isArray(allowed) && allowed.length > 0) {
+                const core = settings?.tools?.core;
+                const exclude = settings?.tools?.exclude;
+                const hasCore = Array.isArray(core) && core.length > 0;
+                const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+                if (hasCore || hasExclude) {
                     return discoverPermissionGroups().map(g => g.name);
                 }
             }
@@ -162,6 +165,28 @@ function buildGrokDetector() {
         },
     };
 }
+function buildGooseDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'goose',
+        list({ versionHome }) {
+            const permissionsPath = path.join(versionHome, '.config', 'goose', 'permission.yaml');
+            if (!fs.existsSync(permissionsPath))
+                return [];
+            try {
+                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
+                const user = config?.user;
+                const count = (Array.isArray(user?.always_allow) ? user.always_allow.length : 0) +
+                    (Array.isArray(user?.ask_before) ? user.ask_before.length : 0) +
+                    (Array.isArray(user?.never_allow) ? user.never_allow.length : 0);
+                if (count > 0)
+                    return discoverPermissionGroups().map(g => g.name);
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
 function buildKimiDetector() {
     return {
         kind: 'permissions',
@@ -248,6 +273,7 @@ const handlers = {
     gemini: buildGeminiDetector,
     antigravity: buildAntigravityDetector,
     grok: buildGrokDetector,
+    goose: buildGooseDetector,
     kimi: buildKimiDetector,
     cursor: buildCursorDetector,
     droid: buildDroidDetector,

package/dist/lib/staleness/detectors/subagents.js

@@ -1,5 +1,5 @@
 /**
- * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * Subagents detector. Claude/Gemini/Grok: flat .md files under `<agentDir>/agents/`.
  * Codex: flat .toml files under `<versionHome>/.codex/agents/`.
  * Droid: flat .md files under `<versionHome>/.factory/droids/`.
  * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
@@ -29,6 +29,9 @@ function buildClaudeDetector() {
 function buildGrokDetector() {
     return buildFlatMdAgentsDetector('grok', '.grok');
 }
+function buildGeminiDetector() {
+    return buildFlatMdAgentsDetector('gemini', '.gemini');
+}
 function buildCodexDetector() {
     return {
         kind: 'subagents',
@@ -128,13 +131,29 @@ function buildOpenCodeDetector() {
         },
     };
 }
+function buildAntigravityDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'antigravity',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.gemini', 'config', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(agentsDir, d.name, 'agent.md')))
+                .map(d => d.name);
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
     copilot: buildCopilotDetector,
+    gemini: buildGeminiDetector,
     grok: buildGrokDetector,
     codex: buildCodexDetector,
     kimi: buildKimiDetector,
     opencode: buildOpenCodeDetector,
+    antigravity: buildAntigravityDetector,
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
     kiro: buildKiroDetector,

package/dist/lib/staleness/detectors/workflows.js

@@ -3,7 +3,9 @@
  * containing WORKFLOW.md. Mirrors versions.ts:551-558.
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
+import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildWorkflowsDetector(agent) {
@@ -11,6 +13,66 @@ function buildWorkflowsDetector(agent) {
         kind: 'workflows',
         agent,
         list({ versionHome }) {
+            if (agent === 'kimi') {
+                const skillsDir = path.join(versionHome, '.kimi-code', 'skills');
+                if (!fs.existsSync(skillsDir))
+                    return [];
+                return fs.readdirSync(skillsDir, { withFileTypes: true })
+                    .filter(d => d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md')))
+                    .filter(d => {
+                    try {
+                        const skill = fs.readFileSync(path.join(skillsDir, d.name, 'SKILL.md'), 'utf-8');
+                        const lines = skill.split('\n');
+                        if (lines[0] !== '---')
+                            return false;
+                        const endIndex = lines.slice(1).findIndex(l => l === '---');
+                        if (endIndex < 0)
+                            return false;
+                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
+                        return parsed?.type === 'flow' && parsed.agents_workflow === d.name;
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                    .map(d => d.name);
+            }
+            if (agent === 'antigravity') {
+                // Antigravity user workflows are HOME-global and shared across versions,
+                // not version-isolated — see workflows.ts:antigravityWorkflowsDir(). agy
+                // scans the real ~/.gemini/config/global_workflows/, so the detector reads
+                // the same shared dir the writer targets (versionHome is intentionally unused).
+                const dir = path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
+                if (!fs.existsSync(dir))
+                    return [];
+                return fs.readdirSync(dir, { withFileTypes: true })
+                    .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
+                    .filter(d => {
+                    try {
+                        const content = fs.readFileSync(path.join(dir, d.name), 'utf-8');
+                        const lines = content.split('\n');
+                        if (lines[0] !== '---')
+                            return false;
+                        const endIndex = lines.slice(1).findIndex(l => l === '---');
+                        if (endIndex < 0)
+                            return false;
+                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
+                        return parsed?.agents_workflow === d.name.slice(0, -'.md'.length);
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                    .map(d => d.name.slice(0, -'.md'.length));
+            }
+            if (agent === 'goose') {
+                const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
+                if (!fs.existsSync(recipesDir))
+                    return [];
+                return fs.readdirSync(recipesDir, { withFileTypes: true })
+                    .filter(d => d.isFile() && d.name.endsWith('.yaml') && !d.name.startsWith('.'))
+                    .map(d => d.name.slice(0, -'.yaml'.length));
+            }
             const workflowsDir = path.join(versionHome, 'workflows');
             if (!fs.existsSync(workflowsDir))
                 return [];

package/dist/lib/staleness/writers/subagents.js

@@ -1,6 +1,7 @@
 /**
- * Subagents writer. Claude flattens each subagent into a single .md file
- * under `<agentDir>/agents/`. Codex writes TOML under `.codex/agents/`.
+ * Subagents writer. Claude/Gemini/Grok flatten each subagent into a single
+ * .md file under their native agents directory. Codex writes TOML under
+ * `.codex/agents/`.
  * Droid (Factory AI) flattens each into a custom droid .md under
  * `<versionHome>/.factory/droids/`. OpenClaw copies the full subagent
  * directory (with AGENT.md renamed to AGENTS.md) into
@@ -13,7 +14,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
+import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForAntigravity, transformSubagentForDroid, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
 import { safeJoin } from '../../paths.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -29,8 +30,9 @@ function buildSubagentsWriter(agent) {
                 if (!sub)
                     continue;
                 try {
-                    if (agent === 'claude' || agent === 'grok') {
-                        const agentsDir = path.join(versionHome, agent === 'grok' ? '.grok' : '.claude', 'agents');
+                    if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+                        const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
+                        const agentsDir = path.join(versionHome, agentsRoot, 'agents');
                         fs.mkdirSync(agentsDir, { recursive: true });
                         fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForClaude(sub.path));
                         synced.push(sub.name);
@@ -51,6 +53,12 @@ function buildSubagentsWriter(agent) {
                         fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForOpenCode(sub.path));
                         synced.push(sub.name);
                     }
+                    else if (agent === 'antigravity') {
+                        const agentDir = safeJoin(path.join(versionHome, '.gemini', 'config', 'agents'), sub.name);
+                        fs.mkdirSync(agentDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentDir, 'agent.md'), transformSubagentForAntigravity(sub.path));
+                        synced.push(sub.name);
+                    }
                     else if (agent === 'droid') {
                         const droidsDir = path.join(versionHome, '.factory', 'droids');
                         fs.mkdirSync(droidsDir, { recursive: true });

package/dist/lib/subagents.d.ts

@@ -68,6 +68,15 @@ export declare function transformSubagentForDroid(subagentDir: string): string;
  * See GitHub docs for custom agents.
  */
 export declare const transformSubagentForCopilot: typeof transformSubagentForDroid;
+/**
+ * Transform a subagent into Antigravity's custom-agent markdown shape.
+ *
+ * Antigravity exposes custom agents as Markdown files with YAML frontmatter,
+ * close to Gemini CLI subagents. Keep portable frontmatter fields and flatten
+ * sibling markdown files into the prompt body like the other markdown-backed
+ * agents.
+ */
+export declare function transformSubagentForAntigravity(subagentDir: string): string;
 /**
  * Transform a subagent into an OpenCode agent markdown file.
  *
@@ -157,7 +166,7 @@ export declare function removeSubagentFromAgent(subagentName: string, agent: Age
 export declare function subagentContentMatches(installedDir: string, sourceDir: string): boolean;
 /**
  * List subagents installed to a specific agent's home
- * Claude: scans ~/.claude/agents/{name}.md
+ * Claude/Gemini/Grok: scans ~/.{agent}/agents/{name}.md
  * Kimi: scans ~/.kimi-code/agents/{name}.yaml (+ sibling .system.md)
  * Kiro: scans ~/.kiro/agents/{name}.json
  * OpenClaw: scans ~/.openclaw/{name}/AGENTS.md

package/dist/lib/subagents.js

@@ -274,6 +274,39 @@ export function transformSubagentForDroid(subagentDir) {
  * See GitHub docs for custom agents.
  */
 export const transformSubagentForCopilot = transformSubagentForDroid;
+/**
+ * Transform a subagent into Antigravity's custom-agent markdown shape.
+ *
+ * Antigravity exposes custom agents as Markdown files with YAML frontmatter,
+ * close to Gemini CLI subagents. Keep portable frontmatter fields and flatten
+ * sibling markdown files into the prompt body like the other markdown-backed
+ * agents.
+ */
+export function transformSubagentForAntigravity(subagentDir) {
+    const agentMd = path.join(subagentDir, 'AGENT.md');
+    const frontmatter = parseSubagentFrontmatter(agentMd);
+    const body = getSubagentBody(agentMd);
+    if (!frontmatter) {
+        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
+    }
+    const frontmatterYaml = yaml.stringify({
+        name: frontmatter.name,
+        description: frontmatter.description,
+        kind: 'local',
+        ...(frontmatter.model && { model: frontmatter.model }),
+    }).trim();
+    let result = `---\n${frontmatterYaml}\n---\n\n${body}`;
+    const files = fs.readdirSync(subagentDir)
+        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
+        .sort();
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
+        const sectionName = file.replace('.md', '');
+        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
+        result += `\n\n## ${title}\n\n${content}`;
+    }
+    return `${result.trim()}\n`;
+}
 /**
  * Transform a subagent into an OpenCode agent markdown file.
  *
@@ -489,10 +522,10 @@ export function syncSubagentToOpenclaw(subagentDir, targetDir) {
  * Install a subagent to a specific agent's home
  */
 export function installSubagentToAgent(subagentDir, subagentName, agent, agentHome) {
-    if (agent === 'claude' || agent === 'grok') {
-        // Claude / Grok: flatten to single .md under ~/.claude/agents or ~/.grok/agents
-        // Grok discovers user agent defs from ~/.grok/agents/*.md (same shape as Claude).
-        const agentsDir = path.join(agentHome, agent === 'grok' ? '.grok' : '.claude', 'agents');
+    if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+        // Claude / Gemini / Grok: flatten to single .md under the native agents dir.
+        const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
+        const agentsDir = path.join(agentHome, agentsRoot, 'agents');
         if (!fs.existsSync(agentsDir)) {
             fs.mkdirSync(agentsDir, { recursive: true });
         }
@@ -543,6 +576,19 @@ export function installSubagentToAgent(subagentDir, subagentName, agent, agentHo
             return { success: false, error: String(err) };
         }
     }
+    else if (agent === 'antigravity') {
+        // Antigravity: custom-agent markdown under ~/.gemini/config/agents/<name>/agent.md.
+        const agentDir = safeJoin(path.join(agentHome, '.gemini', 'config', 'agents'), subagentName);
+        if (!fs.existsSync(agentDir))
+            fs.mkdirSync(agentDir, { recursive: true });
+        try {
+            fs.writeFileSync(safeJoin(agentDir, 'agent.md'), transformSubagentForAntigravity(subagentDir));
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
     else if (agent === 'openclaw') {
         // OpenClaw: copy full directory
         const targetDir = safeJoin(path.join(agentHome, '.openclaw'), subagentName);
@@ -573,8 +619,8 @@ export function installSubagentToAgent(subagentDir, subagentName, agent, agentHo
  */
 export function removeSubagentFromAgent(subagentName, agent, agentHome) {
     try {
-        if (agent === 'claude' || agent === 'grok') {
-            const agentsRoot = agent === 'grok' ? '.grok' : '.claude';
+        if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+            const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
             const targetPath = safeJoin(path.join(agentHome, agentsRoot, 'agents'), `${subagentName}.md`);
             if (fs.existsSync(targetPath)) {
                 fs.unlinkSync(targetPath);
@@ -604,6 +650,12 @@ export function removeSubagentFromAgent(subagentName, agent, agentHome) {
                 fs.unlinkSync(targetPath);
             return { success: true };
         }
+        else if (agent === 'antigravity') {
+            const targetDir = safeJoin(path.join(agentHome, '.gemini', 'config', 'agents'), subagentName);
+            if (fs.existsSync(targetDir))
+                fs.rmSync(targetDir, { recursive: true, force: true });
+            return { success: true };
+        }
         else if (agent === 'openclaw') {
             const targetDir = safeJoin(path.join(agentHome, '.openclaw'), subagentName);
             if (fs.existsSync(targetDir)) {
@@ -655,16 +707,17 @@ export function subagentContentMatches(installedDir, sourceDir) {
 // source of truth.
 /**
  * List subagents installed to a specific agent's home
- * Claude: scans ~/.claude/agents/{name}.md
+ * Claude/Gemini/Grok: scans ~/.{agent}/agents/{name}.md
  * Kimi: scans ~/.kimi-code/agents/{name}.yaml (+ sibling .system.md)
  * Kiro: scans ~/.kiro/agents/{name}.json
  * OpenClaw: scans ~/.openclaw/{name}/AGENTS.md
  */
 export function listSubagentsForAgent(agentId, home) {
     const subagents = [];
-    if (agentId === 'claude' || agentId === 'grok') {
-        // Claude / Grok: flat .md files in agents/
-        const agentsDir = path.join(home, agentId === 'grok' ? '.grok' : '.claude', 'agents');
+    if (agentId === 'claude' || agentId === 'gemini' || agentId === 'grok') {
+        // Claude / Gemini / Grok: flat .md files in agents/
+        const agentsRoot = agentId === 'grok' ? '.grok' : agentId === 'gemini' ? '.gemini' : '.claude';
+        const agentsDir = path.join(home, agentsRoot, 'agents');
         if (!fs.existsSync(agentsDir))
             return subagents;
         for (const file of fs.readdirSync(agentsDir)) {
@@ -730,6 +783,20 @@ export function listSubagentsForAgent(agentId, home) {
             subagents.push({ name, path: filePath, files: [file], frontmatter });
         }
     }
+    else if (agentId === 'antigravity') {
+        const agentsDir = path.join(home, '.gemini', 'config', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const filePath = path.join(agentsDir, entry.name, 'agent.md');
+            if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
+                continue;
+            const frontmatter = parseSubagentFrontmatter(filePath) ?? { name: entry.name, description: '' };
+            subagents.push({ name: entry.name, path: filePath, files: ['agent.md'], frontmatter });
+        }
+    }
     else if (agentId === 'copilot') {
         // Copilot: flat `<name>.agent.md` files under ~/.copilot/agents/
         const agentsDir = path.join(home, '.copilot', 'agents');
@@ -840,8 +907,9 @@ export function diffVersionSubagents(agent, version) {
         }
     }
     // Check what's installed
-    if (agent === 'claude' || agent === 'grok') {
-        const agentsDir = path.join(versionHome, agent === 'grok' ? '.grok' : '.claude', 'agents');
+    if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+        const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
+        const agentsDir = path.join(versionHome, agentsRoot, 'agents');
         if (fs.existsSync(agentsDir)) {
             for (const file of fs.readdirSync(agentsDir)) {
                 if (!file.endsWith('.md'))
@@ -878,6 +946,19 @@ export function diffVersionSubagents(agent, version) {
             }
         }
     }
+    else if (agent === 'antigravity') {
+        const agentsDir = path.join(versionHome, '.gemini', 'config', 'agents');
+        if (fs.existsSync(agentsDir)) {
+            for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                if (!fs.existsSync(path.join(agentsDir, entry.name, 'agent.md')))
+                    continue;
+                if (!discovered.has(entry.name))
+                    orphans.push(entry.name);
+            }
+        }
+    }
     else if (agent === 'openclaw') {
         const openclawDir = path.join(versionHome, '.openclaw');
         if (fs.existsSync(openclawDir)) {
@@ -932,8 +1013,8 @@ export function removeSubagentFromVersion(agent, version, subagentName) {
     const stamp = new Date().toISOString().replace(/[:.]/g, '-');
     const trashDir = path.join(getTrashSubagentsDir(), agent, version, subagentName);
     try {
-        if (agent === 'claude' || agent === 'grok') {
-            const agentsRoot = agent === 'grok' ? '.grok' : '.claude';
+        if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+            const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
             const targetPath = path.join(versionHome, agentsRoot, 'agents', `${subagentName}.md`);
             if (fs.existsSync(targetPath)) {
                 fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
@@ -961,6 +1042,13 @@ export function removeSubagentFromVersion(agent, version, subagentName) {
                 fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.md.${stamp}`));
             }
         }
+        else if (agent === 'antigravity') {
+            const targetDir = path.join(versionHome, '.gemini', 'config', 'agents', subagentName);
+            if (fs.existsSync(targetDir)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetDir, path.join(trashDir, stamp));
+            }
+        }
         else if (agent === 'copilot') {
             const targetPath = path.join(versionHome, '.copilot', 'agents', `${subagentName}.agent.md`);
             if (fs.existsSync(targetPath)) {

package/dist/lib/tmux/session.d.ts

@@ -146,19 +146,25 @@ export declare function setSessionHook(name: string, hook: string, command: stri
  *        in the tmux server instead of launching a second tmux client against
  *        the same socket from inside the hook. That self-client could race the
  *        server under load and leave the dead split behind.
+ *   v5 — `run-shell -b -C "kill-pane -t #{hook_pane}"` runs the targeted kill-pane
+ *        in the background inside the server command queue. The synchronous
+ *        variant could stall the hook on a loaded CI runner, letting the dead
+ *        split survive until the test's wait timeout expired (flake in CI shard
+ *        3: pane-guarded pane-died hook / user split exit).
  */
-export declare const AGENT_HOOK_SCHEMA = 4;
+export declare const AGENT_HOOK_SCHEMA = 5;
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
  * a user split's death runs the else-branch, closing just that split. The
- * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * else-branch goes through `run-shell -b -C` with an explicit `-t #{hook_pane}`
  * target: tmux format-expands the command at fire time and executes it inside
- * the server command queue, so the event pane is always the one killed without
- * launching a second tmux client against the same socket. A bare `kill-pane`
- * relied on the hook context supplying a "current pane", while an external
- * self-client could race the server under load. Single source of truth: both
- * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * the server command queue in the background, so the event pane is always the
+ * one killed without launching a second tmux client against the same socket and
+ * without stalling the hook on a loaded runner. A bare `kill-pane` relied on
+ * the hook context supplying a "current pane", while an external self-client
+ * could race the server under load. Single source of truth: both the
+ * spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
  * two can never drift.
  */
 export declare function agentPaneDiedHook(sessionName: string, agentPane: string): string;

package/dist/lib/tmux/session.js

@@ -93,6 +93,15 @@ export async function createSession(opts) {
     const res = await runTmux({ socket, args, env: opts.env });
     // Only the new-session command in the `;`-chained invocation emits output.
     const pane = /^%\d+$/.test(res.stdout.trim()) ? res.stdout.trim() : undefined;
+    // Keep the agent pane around after its process exits (so runInTmux can read
+    // the exit status and capture the final error), but do NOT keep that behavior
+    // for user-created splits. Apply remain-on-exit to the agent pane only, then
+    // revert the global default so future splits close automatically when their
+    // command finishes. The global-on above protects a fast-exiting agent during
+    // the brief window before the pane option is stamped.
+    if (pane) {
+        await runTmux({ socket, args: ['set-option', '-pt', pane, 'remain-on-exit', 'on', ';', 'set-option', '-g', 'remain-on-exit', 'off'], throwOnError: false }).catch(() => { });
+    }
     const meta = {
         name: opts.name,
         socket,
@@ -294,25 +303,31 @@ export async function setSessionHook(name, hook, command, socket) {
  *        in the tmux server instead of launching a second tmux client against
  *        the same socket from inside the hook. That self-client could race the
  *        server under load and leave the dead split behind.
+ *   v5 — `run-shell -b -C "kill-pane -t #{hook_pane}"` runs the targeted kill-pane
+ *        in the background inside the server command queue. The synchronous
+ *        variant could stall the hook on a loaded CI runner, letting the dead
+ *        split survive until the test's wait timeout expired (flake in CI shard
+ *        3: pane-guarded pane-died hook / user split exit).
  */
-export const AGENT_HOOK_SCHEMA = 4;
+export const AGENT_HOOK_SCHEMA = 5;
 /** Per-session tmux user-option that records which AGENT_HOOK_SCHEMA a session's hook is at. */
 const HOOK_SCHEMA_OPTION = '@ag_hook_schema';
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
  * a user split's death runs the else-branch, closing just that split. The
- * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * else-branch goes through `run-shell -b -C` with an explicit `-t #{hook_pane}`
  * target: tmux format-expands the command at fire time and executes it inside
- * the server command queue, so the event pane is always the one killed without
- * launching a second tmux client against the same socket. A bare `kill-pane`
- * relied on the hook context supplying a "current pane", while an external
- * self-client could race the server under load. Single source of truth: both
- * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * the server command queue in the background, so the event pane is always the
+ * one killed without launching a second tmux client against the same socket and
+ * without stalling the hook on a loaded runner. A bare `kill-pane` relied on
+ * the hook context supplying a "current pane", while an external self-client
+ * could race the server under load. Single source of truth: both the
+ * spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
  * two can never drift.
  */
 export function agentPaneDiedHook(sessionName, agentPane) {
-    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'run-shell -C "kill-pane -t #{hook_pane}"'`;
+    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'run-shell -b -C "kill-pane -t #{hook_pane}"'`;
 }
 /** Stamp a session's hook-schema marker to the current version. */
 export async function markSessionHookSchema(name, socket) {