@phnx-labs/agents-cli 1.20.58 → 1.20.60

package/dist/lib/agents.js

@@ -236,7 +236,7 @@ export const AGENTS = {
         cloudProvider: 'codex',
         // Subagents: multi-agent plumbing since 0.117.0; custom agents as
         // ~/.codex/agents/*.toml (name, description, developer_instructions).
-        capabilities: { hooks: { since: '0.116.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: false, skills: true, commands: { until: '0.117.0' }, plugins: { since: '0.128.0' }, subagents: { since: '0.117.0' }, rules: { file: 'AGENTS.md' }, workflows: false, memory: true, modes: ['plan', 'edit', 'skip'] },
+        capabilities: { hooks: { since: '0.116.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: { since: '0.138.0' }, skills: true, commands: { until: '0.117.0' }, plugins: { since: '0.128.0' }, subagents: { since: '0.117.0' }, rules: { file: 'AGENTS.md' }, workflows: false, memory: true, modes: ['plan', 'edit', 'skip'] },
     },
     gemini: {
         id: 'gemini',
@@ -265,7 +265,8 @@ export const AGENTS = {
             url: 'https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/',
         },
         // gemini hooks: shipped in v0.26.0 (Jan 2026); older binaries silently ignore the `hooks` key.
-        capabilities: { hooks: { since: '0.26.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'GEMINI.md' }, workflows: false, memory: false, modes: ['plan', 'edit', 'skip'], rulesImports: true },
+        // extensions: gemini-extension.json bundles shipped in v0.8.0; custom subagents in v0.36.0.
+        capabilities: { hooks: { since: '0.26.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: true, skills: true, commands: true, plugins: { since: '0.8.0' }, subagents: { since: '0.36.0' }, rules: { file: 'GEMINI.md' }, workflows: false, memory: false, modes: ['plan', 'edit', 'skip'], rulesImports: true },
     },
     cursor: {
         id: 'cursor',
@@ -405,7 +406,10 @@ export const AGENTS = {
         configDir: path.join(HOME, '.config', 'goose'),
         commandsDir: path.join(HOME, '.config', 'goose', 'commands'),
         commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.config', 'goose', 'skills'),
+        // Goose reads skills directly from central ~/.agents/skills/ via the Summon
+        // extension (block-goose-cli ≥ 1.25.0). No per-version copy is written.
+        skillsDir: path.join(HOME, '.agents', 'skills'),
+        nativeAgentsSkillsDir: true,
         // Hooks: Open Plugins format — auto-discovered from
         // ~/.agents/plugins/<name>/hooks/hooks.json (shipped block-goose-cli
         // ≥ 1.34.0). See registerHooksForGoose.
@@ -416,7 +420,8 @@ export const AGENTS = {
         supportsHooks: true,
         // Plugins: Open Plugins under ~/.agents/plugins/<name>/ (same layout as
         // agents-cli source). Version isolation copies into versionHome/.agents/plugins/.
-        capabilities: { hooks: { since: '1.34.0' }, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: false, commands: false, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, memory: false, modes: ['edit'] },
+        // Workflows sync as Goose recipe YAML; permissions sync to permission.yaml.
+        capabilities: { hooks: { since: '1.34.0' }, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: true, skills: { since: '1.25.0' }, commands: false, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: true, memory: false, modes: ['edit'] },
     },
     // Google Antigravity CLI (`agy`) — official replacement for Gemini CLI as of IO 2026.
     // configDir nests inside `~/.gemini/` since agy shares the parent dir with the Gemini
@@ -445,7 +450,7 @@ export const AGENTS = {
         variableSyntax: '{{args}}',
         supportsHooks: true,
         cloudProvider: 'antigravity',
-        capabilities: { hooks: true, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: true, skills: true, commands: true, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, memory: false, modes: ['edit', 'skip'], rulesImports: false },
+        capabilities: { hooks: true, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: true, skills: true, commands: true, plugins: true, subagents: { since: '1.0.16' }, rules: { file: 'AGENTS.md' }, workflows: false, memory: false, modes: ['edit', 'skip'], rulesImports: false },
     },
     // xAI Grok Build CLI (`grok`) — early beta, SuperGrok Heavy. Auth via OAuth on
     // first launch, or XAI_API_KEY env var for headless. MCP servers configured inline
@@ -519,7 +524,7 @@ export const AGENTS = {
             plugins: true,
             subagents: true, // YAML agent files under ~/.kimi-code/agents/ (see transformSubagentForKimi)
             rules: { file: 'AGENTS.md' },
-            workflows: false,
+            workflows: true,
             memory: false,
             modes: ['plan', 'edit', 'auto', 'skip'],
             rulesImports: false,
@@ -560,7 +565,7 @@ export const AGENTS = {
         authFiles: ['auth.v2.file', 'auth.v2.key'],
         commandsDir: path.join(HOME, '.factory', 'commands'),
         commandsSubdir: 'commands',
-        skillsDir: '', // no skills concept
+        skillsDir: path.join(HOME, '.factory', 'skills'),
         hooksDir: 'hooks',
         pluginManifestDir: '.factory-plugin',
         instructionsFile: 'AGENTS.md',
@@ -575,8 +580,8 @@ export const AGENTS = {
             mcp: true,
             mcpHttp: false,
             mcpHeaders: false,
-            allowlist: false,
-            skills: false,
+            allowlist: { since: '0.57.5' },
+            skills: { since: '0.26.0' },
             commands: true,
             plugins: true,
             subagents: true,
@@ -1826,8 +1831,8 @@ export function getUserMcpConfigPath(agentId) {
             // Codex uses TOML config
             return path.join(agent.configDir, 'config.toml');
         case 'opencode':
-            // OpenCode uses JSONC config
-            return path.join(agent.configDir, 'opencode.jsonc');
+            // OpenCode loads ~/.config/opencode/opencode.jsonc (not ~/.opencode/)
+            return path.join(HOME, '.config', 'opencode', 'opencode.jsonc');
         case 'cursor':
             // Cursor uses mcp.json
             return path.join(agent.configDir, 'mcp.json');
@@ -1865,7 +1870,7 @@ export function getMcpConfigPathForHome(agentId, home) {
         case 'codex':
             return path.join(home, '.codex', 'config.toml');
         case 'opencode':
-            return path.join(home, '.opencode', 'opencode.jsonc');
+            return path.join(home, '.config', 'opencode', 'opencode.jsonc');
         case 'cursor':
             return path.join(home, '.cursor', 'mcp.json');
         case 'openclaw':
@@ -1903,7 +1908,8 @@ function getProjectMcpConfigPath(agentId, cwd = process.cwd()) {
         case 'codex':
             return path.join(cwd, `.${agentId}`, 'config.toml');
         case 'opencode':
-            return path.join(cwd, `.${agentId}`, 'opencode.jsonc');
+            // Project config is opencode.jsonc at project root (not .opencode/)
+            return path.join(cwd, 'opencode.jsonc');
         case 'cursor':
             return path.join(cwd, `.${agentId}`, 'mcp.json');
         case 'openclaw':

package/dist/lib/hosts/dispatch.d.ts

@@ -39,8 +39,26 @@ export declare function terminateDispatchedTask(task: HostTask): void;
 export interface DispatchOptions {
     agent: string;
     prompt: string;
+    /** Explicit agent version pin (e.g. "2.1.207") to forward as `agent@version`. */
+    version?: string;
+    /** Explicit run strategy (e.g. "balanced") to forward as `--strategy <strategy>`. */
+    strategy?: string;
     mode?: string;
     model?: string;
+    /** Reasoning effort to forward as `--effort <effort>`. */
+    effort?: string;
+    /** Additional directories to grant, already made remote-portable. */
+    addDir?: string[];
+    /** Stream events as JSON lines. */
+    json?: boolean;
+    /** Show detailed execution logs. */
+    verbose?: boolean;
+    /** Kill the agent after this duration, forwarded as `--timeout <duration>`. */
+    timeout?: string;
+    /** Skip the interactive budget-confirm prompt. */
+    yes?: boolean;
+    /** Route through the Agent Client Protocol. */
+    acp?: boolean;
     remoteCwd?: string;
     /**
      * Force the remote run's NEW session to use this exact id (Claude only, via
@@ -68,10 +86,28 @@ export interface DispatchOptions {
 export declare function buildRunForwardedArgs(opts: DispatchOptions): string[];
 export interface InteractiveDispatchOptions {
     agent: string;
+    /** Explicit agent version pin (e.g. "2.1.207") to forward as `agent@version`. */
+    version?: string;
+    /** Explicit run strategy (e.g. "balanced") to forward as `--strategy <strategy>`. */
+    strategy?: string;
     /** Optional prompt — forwarded only when the caller explicitly forced interactive mode. */
     prompt?: string;
     mode?: string;
     model?: string;
+    /** Reasoning effort to forward as `--effort <effort>`. */
+    effort?: string;
+    /** Additional directories to grant, already made remote-portable. */
+    addDir?: string[];
+    /** Stream events as JSON lines. */
+    json?: boolean;
+    /** Show detailed execution logs. */
+    verbose?: boolean;
+    /** Kill the agent after this duration, forwarded as `--timeout <duration>`. */
+    timeout?: string;
+    /** Skip the interactive budget-confirm prompt. */
+    yes?: boolean;
+    /** Route through the Agent Client Protocol. */
+    acp?: boolean;
     remoteCwd?: string;
     sessionId?: string;
     name?: string;

package/dist/lib/hosts/dispatch.js

@@ -175,11 +175,30 @@ async function launchDetached(host, target, opts) {
  * resume wins when — defensively — both are set.
  */
 export function buildRunForwardedArgs(opts) {
-    const args = ['run', opts.agent, opts.prompt, '--quiet'];
+    const agentArg = opts.version ? `${opts.agent}@${opts.version}` : opts.agent;
+    const args = ['run', agentArg, opts.prompt, '--quiet'];
+    if (opts.strategy)
+        args.push('--strategy', opts.strategy);
     if (opts.mode)
         args.push('--mode', opts.mode);
     if (opts.model)
         args.push('--model', opts.model);
+    if (opts.effort)
+        args.push('--effort', opts.effort);
+    if (opts.addDir) {
+        for (const dir of opts.addDir)
+            args.push('--add-dir', dir);
+    }
+    if (opts.json)
+        args.push('--json');
+    if (opts.verbose)
+        args.push('--verbose');
+    if (opts.timeout)
+        args.push('--timeout', opts.timeout);
+    if (opts.yes)
+        args.push('--yes');
+    if (opts.acp)
+        args.push('--acp');
     if (opts.name)
         args.push('--name', opts.name);
     if (opts.resume)
@@ -196,15 +215,34 @@ export function buildRunForwardedArgs(opts) {
  * infer headless from the prompt).
  */
 export function buildInteractiveRunForwardedArgs(opts) {
-    const args = ['run', opts.agent];
+    const agentArg = opts.version ? `${opts.agent}@${opts.version}` : opts.agent;
+    const args = ['run', agentArg];
     if (opts.prompt && opts.forceInteractive)
         args.push(opts.prompt);
     if (opts.forceInteractive)
         args.push('--interactive');
+    if (opts.strategy)
+        args.push('--strategy', opts.strategy);
     if (opts.mode)
         args.push('--mode', opts.mode);
     if (opts.model)
         args.push('--model', opts.model);
+    if (opts.effort)
+        args.push('--effort', opts.effort);
+    if (opts.addDir) {
+        for (const dir of opts.addDir)
+            args.push('--add-dir', dir);
+    }
+    if (opts.json)
+        args.push('--json');
+    if (opts.verbose)
+        args.push('--verbose');
+    if (opts.timeout)
+        args.push('--timeout', opts.timeout);
+    if (opts.yes)
+        args.push('--yes');
+    if (opts.acp)
+        args.push('--acp');
     if (opts.name)
         args.push('--name', opts.name);
     if (opts.resume)

package/dist/lib/hosts/passthrough.js

@@ -28,6 +28,7 @@ const REMOTE_PASSTHROUGH = {
     view: {},
     usage: {},
     cost: {},
+    output: {},
     doctor: {},
     inspect: {},
     list: {},

package/dist/lib/mcp.js

@@ -485,7 +485,7 @@ function installMcpToForgeConfig(server, versionHome) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
 function installMcpToOpenCodeConfig(server, versionHome) {
-    const configPath = path.join(versionHome, '.opencode', 'opencode.jsonc');
+    const configPath = path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
     let config = {};
     if (fs.existsSync(configPath)) {
         const content = fs.readFileSync(configPath, 'utf-8');

package/dist/lib/output/git-output.d.ts

@@ -0,0 +1,74 @@
+/** Commit tally for one author email. */
+export interface AuthorCommits {
+    author: string;
+    commits: number;
+}
+/** The shipped-work rollup for a window. */
+export interface GitOutputSummary {
+    reposScanned: number;
+    commits: number;
+    byAuthor: AuthorCommits[];
+    prsOpened: number;
+    prsMerged: number;
+    /**
+     * Deduped commit SHAs authored by us in the window. Carried so `--all-hosts`
+     * can UNION across machines — a repo cloned on several boxes exposes the same
+     * commits to `git log` on each, so summing counts would multi-count.
+     */
+    commitShas: string[];
+    /** false when `gh` is missing/unauthed — PR counts are then 0 and not trustworthy. */
+    ghAvailable: boolean;
+    /** Author emails counted as "ours". */
+    authors: string[];
+    /** gh logins queried for PRs. */
+    logins: string[];
+    sinceIso: string;
+}
+export interface GitOutputOptions {
+    /** Root scanned for git repos (e.g. ~/src). */
+    reposDir: string;
+    /** Window start, epoch ms. */
+    sinceMs: number;
+    /** Restrict commit authorship to these emails; default: identities discovered from git config. */
+    authors?: string[];
+    /** gh logins to search PRs for; default: the current `gh api user` login. */
+    logins?: string[];
+    /** Repo discovery depth below reposDir (default 4 — covers ~/src/host/org/repo). */
+    maxDepth?: number;
+    /** Query PRs via gh (default true). */
+    includePrs?: boolean;
+}
+/**
+ * Find git repositories under `root` up to `maxDepth` levels deep. A directory
+ * with a `.git` entry is a repo and is NOT descended into (so nested worktrees
+ * / submodules don't double-count).
+ */
+export declare function findGitRepos(root: string, maxDepth?: number): string[];
+/**
+ * Count commits by our authors across all repos, deduped by SHA (so the same
+ * commit reachable via multiple repo clones/worktrees on this machine — or, at
+ * the fleet layer, across machines — is counted once), tallied per email.
+ */
+export declare function collectCommits(repos: string[], sinceIso: string, authors: string[]): Promise<{
+    total: number;
+    byAuthor: AuthorCommits[];
+    shas: string[];
+}>;
+/**
+ * Count PRs opened and merged in the window across the given logins. `gh search
+ * prs` searches all of GitHub, so one authed gh can cover multiple accounts'
+ * logins. Returns ghAvailable=false if gh can't be reached at all.
+ */
+export declare function collectPrs(logins: string[], sinceDate: string): Promise<{
+    opened: number;
+    merged: number;
+    logins: string[];
+    ghAvailable: boolean;
+}>;
+/** Format an epoch-ms as a YYYY-MM-DD date (UTC), for gh's date-range search. */
+export declare function toSearchDate(ms: number): string;
+/**
+ * Collect the full shipped-work summary for a window: commits (across accounts)
+ * plus PRs opened/merged.
+ */
+export declare function collectGitOutput(options: GitOutputOptions): Promise<GitOutputSummary>;

package/dist/lib/output/git-output.js

@@ -0,0 +1,213 @@
+/**
+ * Git / GitHub "output" collector — the shipped-work half of `agents output`.
+ *
+ * `agents cost` answers "what did we burn?"; this answers "what did we ship?".
+ * It counts commits (across every author identity, so multi-account totals stay
+ * correct regardless of which `gh` login is active) and PRs opened / merged in a
+ * time window. Pure `git`/`gh` over child_process — no server, no telemetry,
+ * mirroring the offline spirit of the cost rollup.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+const execFileAsync = promisify(execFile);
+/** Directory names never descended into during repo discovery. */
+const SKIP_DIRS = new Set(['node_modules', '.git', '.agents', '.worktrees', 'dist', 'build', '.next', '.cache']);
+/**
+ * Find git repositories under `root` up to `maxDepth` levels deep. A directory
+ * with a `.git` entry is a repo and is NOT descended into (so nested worktrees
+ * / submodules don't double-count).
+ */
+export function findGitRepos(root, maxDepth = 4) {
+    const repos = [];
+    const walk = (dir, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip
+        }
+        if (entries.some(e => e.name === '.git')) {
+            repos.push(dir);
+            return; // don't descend into a repo
+        }
+        if (depth >= maxDepth)
+            return;
+        for (const e of entries) {
+            if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name))
+                continue;
+            walk(path.join(dir, e.name), depth + 1);
+        }
+    };
+    walk(root, 0);
+    return repos;
+}
+/** git log for one repo (SHA + author email per commit), tolerant of empty/broken repos. */
+async function repoLog(repoDir, sinceIso) {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', repoDir, 'log', '--all', '--no-merges', `--since=${sinceIso}`, '--pretty=format:%H%x09%ae'], { maxBuffer: 64 * 1024 * 1024 });
+        const refs = [];
+        for (const line of stdout.split('\n')) {
+            const tab = line.indexOf('\t');
+            if (tab < 0)
+                continue;
+            refs.push({ sha: line.slice(0, tab).trim(), email: line.slice(tab + 1).trim() });
+        }
+        return refs;
+    }
+    catch {
+        return []; // no commits yet / not a real repo / detached weirdness
+    }
+}
+/**
+ * Discover the user's own author emails so commit counts exclude teammates.
+ * Union of `git config --global user.email` and each repo's local `user.email`.
+ */
+async function discoverAuthorEmails(repos) {
+    const emails = new Set();
+    try {
+        const { stdout } = await execFileAsync('git', ['config', '--global', 'user.email']);
+        const e = stdout.trim();
+        if (e)
+            emails.add(e.toLowerCase());
+    }
+    catch {
+        /* no global identity */
+    }
+    await Promise.all(repos.map(async (repo) => {
+        try {
+            const { stdout } = await execFileAsync('git', ['-C', repo, 'config', '--get', 'user.email']);
+            const e = stdout.trim();
+            if (e)
+                emails.add(e.toLowerCase());
+        }
+        catch {
+            /* repo has no local identity */
+        }
+    }));
+    return [...emails];
+}
+/**
+ * Count commits by our authors across all repos, deduped by SHA (so the same
+ * commit reachable via multiple repo clones/worktrees on this machine — or, at
+ * the fleet layer, across machines — is counted once), tallied per email.
+ */
+export async function collectCommits(repos, sinceIso, authors) {
+    const ours = new Set(authors.map(a => a.toLowerCase()));
+    const tally = new Map();
+    const seen = new Set();
+    const logs = await Promise.all(repos.map(r => repoLog(r, sinceIso)));
+    for (const refs of logs) {
+        for (const { sha, email } of refs) {
+            const key = email.toLowerCase();
+            if (ours.size > 0 && !ours.has(key))
+                continue;
+            if (seen.has(sha))
+                continue; // same commit seen via another clone/ref
+            seen.add(sha);
+            tally.set(key, (tally.get(key) ?? 0) + 1);
+        }
+    }
+    const byAuthor = [...tally.entries()]
+        .map(([author, commits]) => ({ author, commits }))
+        .sort((a, b) => b.commits - a.commits);
+    return { total: seen.size, byAuthor, shas: [...seen] };
+}
+/** Resolve the current gh login, or null if gh is unavailable/unauthed. */
+async function currentGhLogin() {
+    try {
+        const { stdout } = await execFileAsync('gh', ['api', 'user', '--jq', '.login']);
+        const login = stdout.trim();
+        return login || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Count PRs matching a gh search query (author + date), returning null on failure. */
+async function ghSearchCount(args) {
+    try {
+        const { stdout } = await execFileAsync('gh', [...args, '--limit', '1000', '--json', 'number'], {
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const rows = JSON.parse(stdout);
+        return Array.isArray(rows) ? rows.length : 0;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Count PRs opened and merged in the window across the given logins. `gh search
+ * prs` searches all of GitHub, so one authed gh can cover multiple accounts'
+ * logins. Returns ghAvailable=false if gh can't be reached at all.
+ */
+export async function collectPrs(logins, sinceDate) {
+    let resolved = logins;
+    if (resolved.length === 0) {
+        const login = await currentGhLogin();
+        if (!login)
+            return { opened: 0, merged: 0, logins: [], ghAvailable: false };
+        resolved = [login];
+    }
+    let opened = 0;
+    let merged = 0;
+    let anyOk = false;
+    for (const login of resolved) {
+        const o = await ghSearchCount(['search', 'prs', '--author', login, '--created', `>=${sinceDate}`]);
+        const m = await ghSearchCount(['search', 'prs', '--author', login, '--merged', `>=${sinceDate}`]);
+        if (o !== null) {
+            opened += o;
+            anyOk = true;
+        }
+        if (m !== null) {
+            merged += m;
+            anyOk = true;
+        }
+    }
+    return { opened, merged, logins: resolved, ghAvailable: anyOk };
+}
+/** Format an epoch-ms as a YYYY-MM-DD date (UTC), for gh's date-range search. */
+export function toSearchDate(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/**
+ * Collect the full shipped-work summary for a window: commits (across accounts)
+ * plus PRs opened/merged.
+ */
+export async function collectGitOutput(options) {
+    const reposDir = options.reposDir.replace(/^~(?=$|\/)/, os.homedir());
+    const sinceIso = new Date(options.sinceMs).toISOString();
+    const sinceDate = toSearchDate(options.sinceMs);
+    const repos = findGitRepos(reposDir, options.maxDepth ?? 4);
+    const authors = options.authors && options.authors.length > 0
+        ? options.authors.map(a => a.toLowerCase())
+        : await discoverAuthorEmails(repos);
+    const { total: commits, byAuthor, shas: commitShas } = await collectCommits(repos, sinceIso, authors);
+    let prsOpened = 0;
+    let prsMerged = 0;
+    let ghAvailable = false;
+    let logins = options.logins ?? [];
+    if (options.includePrs !== false) {
+        const prs = await collectPrs(logins, sinceDate);
+        prsOpened = prs.opened;
+        prsMerged = prs.merged;
+        ghAvailable = prs.ghAvailable;
+        logins = prs.logins;
+    }
+    return {
+        reposScanned: repos.length,
+        commits,
+        byAuthor,
+        commitShas,
+        prsOpened,
+        prsMerged,
+        ghAvailable,
+        authors,
+        logins,
+        sinceIso,
+    };
+}

package/dist/lib/permissions.d.ts

@@ -106,17 +106,22 @@ export declare function convertToClaudeFormat(set: PermissionSet): ClaudePermiss
 export declare function convertToCursorFormat(set: PermissionSet): CursorPermissions;
 /**
  * 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 declare function convertToGeminiFormat(set: PermissionSet): {
     tools: {
-        allowed: string[];
+        core: string[];
+        exclude?: string[];
     };
 };
+/** Convert canonical Bash rules into Droid's command arrays. */
+export declare function convertToDroidFormat(set: PermissionSet): {
+    commandAllowlist: string[];
+    commandDenylist: string[];
+};
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -135,6 +140,15 @@ export declare function convertToAntigravityFormat(set: PermissionSet): {
         deny?: string[];
     };
 };
+export interface GoosePermissionConfig {
+    user: {
+        always_allow: string[];
+        ask_before: string[];
+        never_allow: string[];
+    };
+}
+/** Convert canonical permissions to Goose's per-tool permission.yaml shape. */
+export declare function convertToGooseFormat(set: PermissionSet): GoosePermissionConfig;
 /**
  * Convert canonical permission set to Grok format.
  * Grok reads ~/.grok/config.toml with
@@ -212,6 +226,13 @@ export declare function applyClaudePermissions(set: PermissionSet, scope?: 'user
     success: boolean;
     error?: string;
 };
+/**
+ * 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 declare function openCodeConfigPath(scope: 'user' | 'project', cwd?: string, home?: string): string;
 /**
  * Apply a permission set to a specific version's home directory.
  * This writes to {versionHome}/.{agent}/settings.json (or equivalent).