@phnx-labs/agents-cli 1.20.58 → 1.20.60

package/dist/lib/permissions.js

@@ -306,14 +306,21 @@ export function buildPermissionsFromGroups(groupNames) {
             // Matches lines like: - "Bash(git *)" or   - "WebFetch(domain:example.com)"
             // Handles nested quotes that break YAML parsers
             const lines = content.split('\n');
+            let section = null;
             for (const line of lines) {
+                const sectionMatch = line.match(/^\s*(allow|deny)\s*:\s*(?:#.*)?$/);
+                if (sectionMatch) {
+                    section = sectionMatch[1];
+                    continue;
+                }
                 // Match: optional whitespace, dash, whitespace, quote, content, quote
                 // Use greedy match to capture everything between first and last quote
                 const match = line.match(/^\s*-\s*"(.+)"$/);
                 if (match) {
                     const rule = match[1];
-                    // 99-deny group rules go to deny, others to allow
-                    if (groupName === '99-deny' || groupName.includes('-deny')) {
+                    // 99-deny group rules go to deny, others follow their YAML section.
+                    // Legacy group files used bare lists with no section; keep those as allow.
+                    if (section === 'deny' || groupName === '99-deny' || groupName.includes('-deny')) {
                         allDeny.push(rule);
                     }
                     else {
@@ -486,32 +493,40 @@ function parseCanonicalPattern(permission) {
 const BLANKET_BASH_FORMS = new Set(['Bash', 'Bash(*)', 'Bash(**)']);
 /**
  * Convert canonical permission set to Gemini format.
- * Gemini reads tool allow-lists from settings.json under `tools.allowed`.
- * Bash permissions map to run_shell_command(prefix) — the prefix is extracted
- * from the canonical "Bash(cmd:*)" pattern by stripping the trailing ":*".
- * Blanket Bash grants map to bare "run_shell_command" (no prefix filter).
+ * Gemini reads tool allow/deny lists from settings.json under
+ * `tools.core` / `tools.exclude`. Bash permissions map to ShellTool(pattern).
+ * Blanket Bash grants map to bare "ShellTool" (no command filter).
  * Non-Bash tool patterns are skipped; Gemini uses different tool names.
  */
 export function convertToGeminiFormat(set) {
-    const allowed = new Set();
-    for (const perm of set.allow) {
-        if (BLANKET_BASH_FORMS.has(perm)) {
-            allowed.add('run_shell_command');
-            continue;
-        }
-        const parsed = parseCanonicalPattern(perm);
-        if (!parsed || parsed.tool !== 'bash')
-            continue;
-        const colonIdx = parsed.pattern.lastIndexOf(':');
-        const prefix = colonIdx > 0 ? parsed.pattern.slice(0, colonIdx) : parsed.pattern;
-        if (prefix === '*' || prefix === '**') {
-            allowed.add('run_shell_command');
-        }
-        else {
-            allowed.add(`run_shell_command(${prefix})`);
+    const serialize = (permissions) => {
+        const tools = new Set();
+        for (const perm of permissions) {
+            if (BLANKET_BASH_FORMS.has(perm)) {
+                tools.add('ShellTool');
+                continue;
+            }
+            const parsed = parseCanonicalPattern(perm);
+            if (!parsed || parsed.tool !== 'bash')
+                continue;
+            const command = normalizeBashPattern(parsed.pattern);
+            if (command === '*') {
+                tools.add('ShellTool');
+            }
+            else {
+                tools.add(`ShellTool(${command})`);
+            }
         }
-    }
-    return { tools: { allowed: Array.from(allowed) } };
+        return Array.from(tools);
+    };
+    const core = serialize(set.allow);
+    const exclude = serialize(set.deny ?? []);
+    return {
+        tools: {
+            core,
+            ...(exclude.length ? { exclude } : {}),
+        },
+    };
 }
 /**
  * Strip Claude's `:*` subcommand-wildcard suffix and return a space-glob form.
@@ -525,6 +540,26 @@ function normalizeBashPattern(pattern) {
         return pattern.slice(0, -2) + ' *';
     return pattern;
 }
+/** Convert canonical Bash rules into Droid's command arrays. */
+export function convertToDroidFormat(set) {
+    const commands = (permissions) => {
+        const result = new Set();
+        for (const permission of permissions) {
+            if (BLANKET_BASH_FORMS.has(permission)) {
+                result.add('*');
+                continue;
+            }
+            const parsed = parseCanonicalPattern(permission);
+            if (parsed?.tool === 'bash')
+                result.add(normalizeBashPattern(parsed.pattern));
+        }
+        return Array.from(result);
+    };
+    return {
+        commandAllowlist: commands(set.allow),
+        commandDenylist: commands(set.deny ?? []),
+    };
+}
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -576,6 +611,49 @@ const ANTIGRAVITY_ACTION_BY_TOOL = {
     write: 'write_file',
     webfetch: 'read_url',
 };
+const GOOSE_TOOL_BY_CANONICAL = {
+    bash: 'developer__shell',
+    read: 'developer__text_editor',
+    write: 'developer__text_editor',
+    edit: 'developer__text_editor',
+    grep: 'developer__analyze',
+    glob: 'developer__analyze',
+    webfetch: 'developer__fetch',
+    mcp: undefined,
+};
+function canonicalToGooseTool(permission) {
+    if (BLANKET_BASH_FORMS.has(permission))
+        return 'developer__shell';
+    const parsed = parseCanonicalPattern(permission);
+    if (!parsed)
+        return null;
+    return GOOSE_TOOL_BY_CANONICAL[parsed.tool] ?? null;
+}
+/** Convert canonical permissions to Goose's per-tool permission.yaml shape. */
+export function convertToGooseFormat(set) {
+    const alwaysAllow = new Set();
+    const neverAllow = new Set();
+    for (const permission of set.allow) {
+        const tool = canonicalToGooseTool(permission);
+        if (tool)
+            alwaysAllow.add(tool);
+    }
+    for (const permission of set.deny ?? []) {
+        const tool = canonicalToGooseTool(permission);
+        if (tool)
+            neverAllow.add(tool);
+    }
+    for (const tool of neverAllow) {
+        alwaysAllow.delete(tool);
+    }
+    return {
+        user: {
+            always_allow: Array.from(alwaysAllow).sort(),
+            ask_before: [],
+            never_allow: Array.from(neverAllow).sort(),
+        },
+    };
+}
 /**
  * Convert canonical permission set to Grok format.
  * Grok reads ~/.grok/config.toml with
@@ -919,9 +997,7 @@ function readClaudePermissions(scope = 'user', cwd, options) {
  */
 function readOpenCodePermissions(scope = 'user', cwd, options) {
     const home = options?.home || HOME;
-    const configPath = scope === 'user'
-        ? path.join(home, '.opencode', 'opencode.jsonc')
-        : path.join(cwd || process.cwd(), '.opencode', 'opencode.jsonc');
+    const configPath = openCodeConfigPath(scope, cwd, home);
     if (!fs.existsSync(configPath)) {
         return null;
     }
@@ -1031,14 +1107,36 @@ export function applyClaudePermissions(set, scope = 'user', cwd, merge = true) {
         return { success: false, error: err.message };
     }
 }
+/**
+ * Path OpenCode actually loads for global config:
+ *   ~/.config/opencode/opencode.jsonc  (or .json)
+ * Project: <cwd>/opencode.jsonc (or .json) at project root — not .opencode/.
+ * See https://opencode.ai/docs/config/
+ */
+export function openCodeConfigPath(scope, cwd, home = HOME) {
+    if (scope === 'project') {
+        const root = cwd || process.cwd();
+        for (const name of ['opencode.jsonc', 'opencode.json']) {
+            const candidate = path.join(root, name);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        return path.join(root, 'opencode.jsonc');
+    }
+    const globalDir = path.join(home, '.config', 'opencode');
+    for (const name of ['opencode.jsonc', 'opencode.json']) {
+        const candidate = path.join(globalDir, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return path.join(globalDir, 'opencode.jsonc');
+}
 /**
  * Apply a permission set to OpenCode's opencode.jsonc.
  */
 function applyOpenCodePermissions(set, scope = 'user', cwd, merge = true) {
-    const configDir = scope === 'user'
-        ? path.join(HOME, '.opencode')
-        : path.join(cwd || process.cwd(), '.opencode');
-    const configPath = path.join(configDir, 'opencode.jsonc');
+    const configPath = openCodeConfigPath(scope, cwd);
+    const configDir = path.dirname(configPath);
     try {
         // Ensure directory exists
         if (!fs.existsSync(configDir)) {
@@ -1172,7 +1270,10 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             return { success: true };
         }
         if (agentId === 'opencode') {
-            const configPath = path.join(configDir, 'opencode.jsonc');
+            // OpenCode loads ~/.config/opencode/opencode.jsonc under the version home
+            // (HOME isolation), not ~/.opencode/opencode.jsonc.
+            const configPath = openCodeConfigPath('user', undefined, versionHome);
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
             let config = {};
             if (fs.existsSync(configPath)) {
                 const content = stripJsonComments(fs.readFileSync(configPath, 'utf-8'));
@@ -1231,17 +1332,29 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             const geminiPerms = convertToGeminiFormat(set);
             const settingsPath = path.join(versionHome, '.gemini', 'settings.json');
             updateGeminiSettings(settingsPath, (settings) => {
-                // Remove stale permissions key written by earlier versions of this serializer.
+                // Remove stale keys written by earlier serializer versions:
+                // top-level `permissions`, and Gemini's pre-core/exclude `tools.allowed`.
                 delete settings.permissions;
                 const tools = (typeof settings.tools === 'object' && settings.tools !== null && !Array.isArray(settings.tools))
                     ? settings.tools
                     : {};
+                delete tools.allowed;
                 if (merge) {
-                    const existing = Array.isArray(tools.allowed) ? tools.allowed : [];
-                    tools.allowed = Array.from(new Set([...existing, ...geminiPerms.tools.allowed]));
+                    const existingCore = Array.isArray(tools.core) ? tools.core : [];
+                    const existingExclude = Array.isArray(tools.exclude) ? tools.exclude : [];
+                    tools.core = Array.from(new Set([...existingCore, ...geminiPerms.tools.core]));
+                    const mergedExclude = Array.from(new Set([...existingExclude, ...(geminiPerms.tools.exclude ?? [])]));
+                    if (mergedExclude.length)
+                        tools.exclude = mergedExclude;
+                    else
+                        delete tools.exclude;
                 }
                 else {
-                    tools.allowed = geminiPerms.tools.allowed;
+                    tools.core = geminiPerms.tools.core;
+                    if (geminiPerms.tools.exclude?.length)
+                        tools.exclude = geminiPerms.tools.exclude;
+                    else
+                        delete tools.exclude;
                 }
                 settings.tools = tools;
             });
@@ -1306,6 +1419,47 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             fs.writeFileSync(configPath, TOML.stringify(config), 'utf-8');
             return { success: true };
         }
+        if (agentId === 'goose') {
+            const permissionsPath = path.join(versionHome, '.config', 'goose', 'permission.yaml');
+            let config = {};
+            if (fs.existsSync(permissionsPath)) {
+                const parsed = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    config = parsed;
+                }
+            }
+            const converted = convertToGooseFormat(set).user;
+            const user = (typeof config.user === 'object' && config.user !== null && !Array.isArray(config.user))
+                ? config.user
+                : {};
+            const currentAlways = Array.isArray(user.always_allow) ? user.always_allow.filter((v) => typeof v === 'string') : [];
+            const currentAsk = Array.isArray(user.ask_before) ? user.ask_before.filter((v) => typeof v === 'string') : [];
+            const currentNever = Array.isArray(user.never_allow) ? user.never_allow.filter((v) => typeof v === 'string') : [];
+            if (merge) {
+                const incomingAlways = new Set(converted.always_allow);
+                const incomingNever = new Set(converted.never_allow);
+                const touched = new Set([...incomingAlways, ...incomingNever]);
+                const always = new Set(currentAlways.filter(tool => !touched.has(tool)));
+                const ask = new Set(currentAsk.filter(tool => !touched.has(tool)));
+                const never = new Set(currentNever.filter(tool => !touched.has(tool)));
+                for (const tool of incomingAlways)
+                    always.add(tool);
+                for (const tool of incomingNever)
+                    never.add(tool);
+                user.always_allow = Array.from(always).sort();
+                user.ask_before = Array.from(ask).sort();
+                user.never_allow = Array.from(never).sort();
+            }
+            else {
+                user.always_allow = converted.always_allow;
+                user.ask_before = converted.ask_before;
+                user.never_allow = converted.never_allow;
+            }
+            config.user = user;
+            fs.mkdirSync(path.dirname(permissionsPath), { recursive: true });
+            fs.writeFileSync(permissionsPath, yaml.stringify(config), 'utf-8');
+            return { success: true };
+        }
         if (agentId === 'kimi') {
             const configPath = path.join(versionHome, '.kimi-code', 'config.toml');
             let config = {};
@@ -1364,6 +1518,27 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
             return { success: true };
         }
+        if (agentId === 'droid') {
+            const configPath = path.join(versionHome, '.factory', 'settings.json');
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            }
+            const converted = convertToDroidFormat(set);
+            if (merge) {
+                const existingAllow = Array.isArray(config.commandAllowlist) ? config.commandAllowlist : [];
+                const existingDeny = Array.isArray(config.commandDenylist) ? config.commandDenylist : [];
+                config.commandAllowlist = Array.from(new Set([...existingAllow, ...converted.commandAllowlist]));
+                config.commandDenylist = Array.from(new Set([...existingDeny, ...converted.commandDenylist]));
+            }
+            else {
+                config.commandAllowlist = converted.commandAllowlist;
+                config.commandDenylist = converted.commandDenylist;
+            }
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            return { success: true };
+        }
         if (agentId === 'kiro') {
             const permissionsPath = path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
             let config = {};
@@ -1496,7 +1671,7 @@ export function exportPermissionsFromPath(filePath) {
     if (fileName === 'settings.json' && parentDir === '.claude') {
         agentId = 'claude';
     }
-    else if (fileName === 'opencode.jsonc' || parentDir === '.opencode') {
+    else if (fileName === 'opencode.jsonc' || fileName === 'opencode.json' || parentDir === 'opencode' || parentDir === '.opencode') {
         agentId = 'opencode';
     }
     else if (fileName === 'config.toml' && parentDir === '.codex') {

package/dist/lib/plugins.d.ts

@@ -191,6 +191,14 @@ export declare function resolveOpenCodePluginSources(pluginRoot: string): string
 export declare function installOpenCodePlugin(plugin: DiscoveredPlugin, versionHome: string): boolean;
 export declare function isOpenCodePluginInstalled(pluginName: string, versionHome: string): boolean;
 export declare function removeOpenCodePlugin(pluginName: string, versionHome: string): boolean;
+/**
+ * Gemini CLI extensions live under `$HOME/.gemini/extensions/<name>/` and
+ * require a `gemini-extension.json` manifest at the extension root.
+ */
+export declare function geminiExtensionsDir(versionHome: string): string;
+export declare function installGeminiPlugin(plugin: DiscoveredPlugin, versionHome: string): boolean;
+export declare function isGeminiPluginInstalled(pluginName: string, versionHome: string): boolean;
+export declare function removeGeminiPlugin(pluginName: string, versionHome: string): boolean;
 /**
  * Goose auto-discovers Open Plugins at `$HOME/.agents/plugins/<name>/`.
  * Under agents-cli version isolation HOME is the version home, so we install to:

package/dist/lib/plugins.js

@@ -21,6 +21,7 @@ import { shouldInstallCommandAsSkill, installCommandSkillToVersion } from './com
 import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, registerDroidInstalledPlugin, unregisterDroidInstalledPlugin, isDroidPluginInstalled, registerCopilotInstalledPlugin, unregisterCopilotInstalledPlugin, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, } from './plugin-marketplace.js';
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
+const GEMINI_EXTENSION_MANIFEST_FILE = 'gemini-extension.json';
 const USER_CONFIG_FILE = '.user-config.json';
 const SOURCE_FILE = '.source';
 export const PLUGIN_EXEC_SURFACE_LABELS = {
@@ -502,6 +503,27 @@ export function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
             result.skills.push(plugin.name);
         return result;
     }
+    // Gemini CLI loads extensions from $HOME/.gemini/extensions/<name>/.
+    // Copy the plugin bundle as an extension and synthesize gemini-extension.json.
+    if (agent === 'gemini') {
+        const enablePlugin = options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root));
+        if (!enablePlugin) {
+            return result;
+        }
+        const ok = installGeminiPlugin(plugin, versionHome);
+        result.success = ok;
+        if (ok) {
+            result.skills = plugin.skills.map(s => `${plugin.name}:${s}`);
+            result.commands = plugin.commands.map(c => `${plugin.name}:${c}`);
+            result.agentDefs = plugin.agentDefs.map(a => `${plugin.name}:${a}`);
+            result.bin = plugin.bin;
+            result.hooks = plugin.hooks;
+            result.mcp = plugin.hasMcp;
+            result.settings = plugin.hasSettings;
+            result.permissions = pluginHasPermissions(plugin);
+        }
+        return result;
+    }
     // Goose loads Open Plugins from $HOME/.agents/plugins/<name>/ (same layout as
     // agents-cli's source tree). Under the shim HOME is the version home.
     if (agent === 'goose') {
@@ -901,6 +923,82 @@ export function removeOpenCodePlugin(pluginName, versionHome) {
     }
     return removed;
 }
+// ─── Gemini extensions ───────────────────────────────────────────────────────
+/**
+ * Gemini CLI extensions live under `$HOME/.gemini/extensions/<name>/` and
+ * require a `gemini-extension.json` manifest at the extension root.
+ */
+export function geminiExtensionsDir(versionHome) {
+    return path.join(versionHome, '.gemini', 'extensions');
+}
+function readPluginMcpConfigForGemini(pluginRoot) {
+    const mcpPath = path.join(pluginRoot, '.mcp.json');
+    if (!fs.existsSync(mcpPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        if (!parsed.mcpServers || typeof parsed.mcpServers !== 'object')
+            return undefined;
+        return rewriteGeminiExtensionVars(parsed.mcpServers);
+    }
+    catch {
+        return undefined;
+    }
+}
+function rewriteGeminiExtensionVars(value) {
+    if (typeof value === 'string') {
+        return value
+            .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${extensionPath}')
+            .replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, '${extensionPath}/.data');
+    }
+    if (Array.isArray(value))
+        return value.map(rewriteGeminiExtensionVars);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, rewriteGeminiExtensionVars(item)]));
+    }
+    return value;
+}
+function writeGeminiExtensionManifest(plugin, destRoot) {
+    const manifest = {
+        name: plugin.manifest.name,
+        version: plugin.manifest.version,
+        description: plugin.manifest.description,
+    };
+    const mcpServers = readPluginMcpConfigForGemini(destRoot);
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+        manifest.mcpServers = mcpServers;
+    }
+    fs.writeFileSync(path.join(destRoot, GEMINI_EXTENSION_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+}
+export function installGeminiPlugin(plugin, versionHome) {
+    const destRoot = path.join(geminiExtensionsDir(versionHome), plugin.name);
+    try {
+        if (fs.existsSync(destRoot)) {
+            fs.rmSync(destRoot, { recursive: true, force: true });
+        }
+        fs.cpSync(plugin.root, destRoot, { recursive: true });
+        const userConfig = loadUserConfig(plugin.name);
+        if (Object.keys(userConfig).length > 0) {
+            expandUserConfigInDir(destRoot, userConfig);
+        }
+        writeGeminiExtensionManifest(plugin, destRoot);
+        fs.writeFileSync(path.join(destRoot, '.agents-cli-managed'), `plugin=${plugin.name}\n`, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isGeminiPluginInstalled(pluginName, versionHome) {
+    return fs.existsSync(path.join(geminiExtensionsDir(versionHome), pluginName, GEMINI_EXTENSION_MANIFEST_FILE));
+}
+export function removeGeminiPlugin(pluginName, versionHome) {
+    const destRoot = path.join(geminiExtensionsDir(versionHome), pluginName);
+    if (!fs.existsSync(destRoot))
+        return false;
+    fs.rmSync(destRoot, { recursive: true, force: true });
+    return true;
+}
 // ─── Goose plugins (Open Plugins under .agents/plugins/) ─────────────────────
 /**
  * Goose auto-discovers Open Plugins at `$HOME/.agents/plugins/<name>/`.
@@ -949,6 +1047,9 @@ export function isPluginSynced(plugin, agent, versionHome) {
     if (agent === 'opencode') {
         return isOpenCodePluginInstalled(plugin.name, versionHome);
     }
+    if (agent === 'gemini') {
+        return isGeminiPluginInstalled(plugin.name, versionHome);
+    }
     if (agent === 'goose') {
         return isGoosePluginInstalled(plugin.name, versionHome);
     }
@@ -986,6 +1087,13 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
         }
         return result;
     }
+    // Gemini: remove extension directory from ~/.gemini/extensions/.
+    if (agent === 'gemini') {
+        if (removeGeminiPlugin(pluginName, versionHome)) {
+            result.skills.push(pluginName);
+        }
+        return result;
+    }
     // Goose: remove Open Plugin directory from versionHome/.agents/plugins/.
     if (agent === 'goose') {
         if (removeGoosePlugin(pluginName, versionHome)) {

package/dist/lib/project-root.js

@@ -16,6 +16,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { readMeta, updateMeta } from './state.js';
 import { getMainRepoRoot } from './git.js';
+import { toPosix } from './platform/index.js';
 const HOME = process.env.HOME ?? os.homedir();
 /** Rewrite an absolute path under the local home to a `~/`-relative string; pass others through. */
 export function toHomeRelative(abs) {
@@ -23,7 +24,7 @@ export function toHomeRelative(abs) {
     if (rel === '')
         return '~';
     if (!rel.startsWith('..') && !path.isAbsolute(rel))
-        return `~/${rel}`;
+        return `~/${toPosix(rel)}`;
     return abs;
 }
 /** Expand a leading `~`/`$HOME` against the LOCAL home. Other paths pass through unchanged. */

package/dist/lib/resources/mcp.js

@@ -111,7 +111,7 @@ export function getMcpConfigPath(agent, versionHome) {
         case 'codex':
             return path.join(versionHome, '.codex', 'config.toml');
         case 'opencode':
-            return path.join(versionHome, '.opencode', 'opencode.jsonc');
+            return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
         case 'cursor':
             return path.join(versionHome, '.cursor', 'mcp.json');
         case 'gemini':

package/dist/lib/resources/permissions.d.ts

@@ -4,7 +4,7 @@
  * Permissions are stored as YAML files in permissions/ directories at each layer.
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
+ * (Claude/Gemini: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
  */
 import type { ResourceHandler } from './types.js';
 import type { PermissionSet } from '../types.js';

package/dist/lib/resources/permissions.js

@@ -4,7 +4,7 @@
  * Permissions are stored as YAML files in permissions/ directories at each layer.
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
+ * (Claude/Gemini: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -65,12 +65,18 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.claude', 'settings.json');
         case 'codex':
             return path.join(versionHome, '.codex', 'config.toml');
+        case 'gemini':
+            return path.join(versionHome, '.gemini', 'settings.json');
         case 'opencode':
-            return path.join(versionHome, '.opencode', 'opencode.jsonc');
+            return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
         case 'kimi':
             return path.join(versionHome, '.kimi-code', 'config.toml');
+        case 'droid':
+            return path.join(versionHome, '.factory', 'settings.json');
         case 'kiro':
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
+        case 'goose':
+            return path.join(versionHome, '.config', 'goose', 'permission.yaml');
         default:
             return null;
     }

package/dist/lib/resources/skills.js

@@ -5,7 +5,7 @@
  * Format is the same for all agents. Resolution order: project > user > system.
  */
 import * as fs from 'fs';
-import { agentConfigDirName } from '../agents.js';
+import { AGENTS, agentConfigDirName } from '../agents.js';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getSystemSkillsDir, getUserSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
@@ -201,6 +201,11 @@ export function createSkillsHandler(provider = defaultProvider) {
             return null;
         },
         sync(agent, versionHome, cwd) {
+            // Agents that read directly from central ~/.agents/skills/ (e.g. Gemini,
+            // Goose via the Summon extension) should not get a per-version copy.
+            if (AGENTS[agent]?.nativeAgentsSkillsDir) {
+                return;
+            }
             const targetDir = path.join(versionHome, agentConfigDirName(agent), 'skills');
             // Ensure target directory exists
             if (!fs.existsSync(targetDir)) {

package/dist/lib/resources/types.d.ts

@@ -5,7 +5,7 @@
  * - Union: All resources from all layers are combined
  * - Override on name conflict: Higher layer wins (project > user > system)
  */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'antigravity' | 'grok' | 'kimi' | 'hermes' | 'forge';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
 export type Layer = 'system' | 'user' | 'project';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';
 /** A resolved resource with its origin layer. */

package/dist/lib/routines.d.ts

@@ -138,6 +138,22 @@ export declare function readJob(name: string, cwd?: string): JobConfig | null;
  * name, the write fails explicitly so we never choose or drop a sibling.
  */
 export declare function writeJob(config: JobConfig): void;
+/**
+ * Serialize a job config, preserving the on-disk formatting of an existing file.
+ *
+ * A full `yaml.stringify(config)` re-emits the whole document — restyling every
+ * scalar (unquoting `schedule`, re-wrapping the folded `prompt` block, reordering
+ * keys). When a routine is only being toggled (pause/resume) or re-pinned
+ * (`devices --set`), that rewrites the entire file, leaving the git-backed
+ * `~/.agents` tree perpetually dirty so `agents repo pull` refuses to sync across
+ * the fleet. To keep the diff to the field that actually changed, we edit the
+ * existing document in place and only re-render touched nodes; untouched nodes
+ * (notably the large `prompt` block) keep their byte-for-byte formatting.
+ *
+ * `existingText` is the current file contents, or null for a new file. New,
+ * unparseable, and non-mapping documents fall back to canonical `yaml.stringify`.
+ */
+export declare function serializeJob(output: Record<string, unknown>, existingText: string | null): string;
 /** Delete a job config file by name. Returns true if the file existed. */
 export declare function deleteJob(name: string): boolean;
 /** Enable or disable a job by name. */