@phnx-labs/agents-cli 1.20.59 → 1.20.61

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 1.20.61
+
+- **Detect OpenCode sign-in state so `agents view` stops mislabeling a logged-in install as "not signed in."** `getAccountInfo` had no `opencode` case, so it fell through to `signedIn: false` and every row printed "(not signed in — run opencode to log in)" even with a live login. It now reads OpenCode's `auth.json` (`$XDG_DATA_HOME/opencode/auth.json`, defaulting to `~/.local/share/opencode/auth.json` on every platform — `xdg-basedir` does not special-case macOS), validates each provider entry against its `oauth`/`api`/`wellknown` credential shape, and reports the account as signed in with the non-secret provider ids surfaced as the account label (e.g. `id:muse-spark`). Credential secrets (`access`/`refresh`/`key`/`token`) are only inspected for presence — never read into any display or JSON output. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/agents.test.ts`.
+- **Wire Antigravity workflows support (RUSH-1580).** `agents` now syncs workflows to Antigravity as markdown files with the required `description` frontmatter plus an `agents_workflow` ownership marker, invocable as `/<name>` slash commands. Antigravity workflows are the one non-version-isolated target: `agy` scans a single shared, HOME-global `~/.gemini/config/global_workflows/` at startup (a real home directory, never symlinked per version — verified via strace of `agy`), so the writer and detector both resolve that shared dir for every installed version instead of a per-version home. Gated at `>= 1.0.6`. The ownership marker prevents overwriting or removing user-authored workflows of the same name. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/workflows.ts`, `apps/cli/src/lib/staleness/detectors/workflows.ts`.
+
+## 1.20.60
+- **Fix Goose skill sync status for its native central-storage path.** `agents skills list goose@<version>` now reports skills under `~/.agents/skills/` as installed instead of falsely requiring a per-version `.config/goose/skills/` copy that Goose never reads. Source: `apps/cli/src/lib/skills.ts`.
+- **Correct the documented `auto` and ACP `skip` semantics.** The README and bundled `run` skill now distinguish Kimi's interactive `--auto` from its already-auto-approved headless `-p` path, document Droid's native `--auto high`, and explain that ACP `skip` prefers `allow_always` but falls back to the first permission option offered by the server. Documentation only; runtime behavior is unchanged. Source: `README.md`, `skills/run/SKILL.md`.
+- **Wire Antigravity subagents and Kimi workflow sync (RUSH-1548, RUSH-1581).** Antigravity now receives subagents as custom-agent Markdown under `~/.gemini/config/agents/<name>/agent.md` with the `>= 1.0.16` version gate enforced during sync. Kimi receives workflows as managed `type: flow` skills under `.kimi-code/skills/<name>/SKILL.md`, using the canonical slug as the flow name and an `agents_workflow` marker so native user-owned flows are not overwritten or removed. Antigravity workflows are wired separately in RUSH-1580 (they target a shared HOME-global dir, not a version home). Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/workflows.ts`.
+- **Release retries rebuild the exact merged, CI-tested release tree even after `main` advances.** A registry/auth failure after the release PR merged previously stranded that version because the catch-up guard required the release merge to remain current `main`. The local release script now validates the original PR head and full green matrix, verifies the SHA-pinned keychain helper, rebuilds the unpinned menu-bar helper from historical source in a detached temporary worktree, rejects mismatched remote tags, and tags/publishes that exact merge without including later commits. Source: `apps/cli/scripts/release.sh`.
+- **Wire Gemini plugins/subagents and Goose workflows/allowlists.** Gemini now syncs plugin bundles as Gemini extensions (`.gemini/extensions/<name>/gemini-extension.json`) from CLI 0.8.0+ and subagents as `.gemini/agents/*.md` from CLI 0.36.0+. Goose now syncs workflows as recipe/subrecipe YAML under `.config/goose/recipes/` and permission groups into `.config/goose/permission.yaml`. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/plugins.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/workflows.ts`, `apps/cli/src/lib/permissions.ts`. (RUSH-1568, RUSH-1569, RUSH-1574, RUSH-1582)
+- **Wire Gemini permissions/allowlist support (RUSH-1567).** Gemini permission groups now sync Bash allow/deny rules into `.gemini/settings.json` as `tools.core` / `tools.exclude` entries with per-command `ShellTool(...)` patterns; non-Bash canonical permissions remain unsupported by Gemini's native tool grammar and are skipped. Flip `allowlist: true`, register the permission writer/detector through the capability table, and replace the dormant legacy `tools.allowed` serializer. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`, `apps/cli/src/lib/resources/permissions.ts`, `apps/cli/src/lib/staleness/detectors/permissions.ts`.
+- **Fix: `agents run <agent>@<version> --host <host>` now forwards the version pin and most run flags to the remote host.** Previously the `--host` branch stripped `@version` and ignored `--strategy`, `--effort`, `--add-dir`, `--json`, `--verbose`, `--timeout`, `--yes`, and `--acp`, so the remote host applied its own defaults. The local CLI now parses `agent@version` verbatim, normalizes `--strategy`/`--balanced`, makes `--add-dir` paths remote-portable, and forwards all of these flags to the remote `agents run` invocation. `--add-dir` portability uses the same `~`/`$HOME` re-rooting that `--cwd` already uses, so a Linux remote resolves home paths against its own `/home/<user>`. Source: `apps/cli/src/lib/hosts/dispatch.ts`, `apps/cli/src/commands/exec.ts`, `apps/cli/src/lib/hosts/dispatch.test.ts`.
+- **Fix: routine edits no longer rewrite the whole YAML file, so `~/.agents` stays clean and `agents repo pull` can sync routines across the fleet.** `writeJob` previously re-emitted the entire document via `yaml.stringify` on every mutation (pause/resume, `routines devices --set`, add), restyling untouched scalars — unquoting `schedule`, re-wrapping the folded `prompt` block — which left the git-backed user repo perpetually dirty. That made cross-device `agents repo pull` refuse ("uncommitted changes"), so a `devices:` pin set on one machine never reached the others and `Devices: all` routines kept firing on every box. A new `serializeJob` edits only the changed keys via the YAML Document API, preserving byte-for-byte formatting of untouched nodes; new/unparseable/non-mapping files fall back to canonical stringify. Source: `apps/cli/src/lib/routines.ts`, `apps/cli/src/lib/__tests__/routines.serialize.test.ts`.
+
 ## 1.20.59
 
 - **Fix: remote secrets now choose the Windows PowerShell wrapper from the original `--host` name, not the resolved `user@ip` SSH target.** Inline enrolled Windows hosts resolve to address-based SSH targets, but the OS registry is keyed by the host name; `agents secrets view/list/exec --host <windows>`, `agents run --secrets bundle@<windows>`, and remote secrets unlock/export paths now pass that original name into command construction so Windows hosts no longer fall back to `bash -lc`. Source: `apps/cli/src/lib/secrets/remote.ts`, `apps/cli/src/commands/secrets.ts`, `apps/cli/src/commands/exec.ts`. (RUSH-1431)
@@ -12,6 +27,8 @@
 - **OpenCode permissions write to the loaded config path (RUSH-1623).** Global config is `~/.config/opencode/opencode.jsonc` (not `~/.opencode/`); project config is `opencode.jsonc` at the project root. Source: `apps/cli/src/lib/permissions.ts`, `apps/cli/src/lib/agents.ts`.
 - **Catch-up publishes now require the exact CI-tested release tree and its full green matrix.** A package version already present on `main` no longer counts as release validation by itself: `release.sh` resolves the merged `release/v<version>` PR, requires its merge commit to be current `main`, fetches the PR head that ran CI, requires that head tree to equal current `main`, and rechecks every expected CI context before publishing. This closes the path that let 1.20.58 reach npm before its tag-triggered Windows matrix exposed failures. Source: `apps/cli/scripts/release.sh`.
 - **Windows release validation now matches portable path behavior.** Home-relative project paths normalize native separators to `/` before they are stored as `~/…`, and the systemd-manifest and remote-shell assertions now compare the escaped/quoted forms that the runtime deliberately emits. This restores the Windows Node 22/24 release matrix without weakening command escaping. Source: `apps/cli/src/lib/project-root.ts`, `apps/cli/src/lib/{project-root,daemon}.test.ts`, `apps/cli/src/lib/hosts/dispatch.test.ts`.
+- **Wire subagents support for Kiro CLI.** Kiro custom agents are JSON files under `~/.kiro/agents/*.json` (introduced in kiro-cli v1.23.0). Flip Kiro's `subagents: { since: '1.23.0' }`, add `transformSubagentForKiro`, and wire the subagents writer, detector, install/remove, and orphan-detection paths. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/staleness/{writers,detectors}/subagents.ts`. (RUSH-1393)
+
 ## 1.20.58
 
 - **Self-updating agent CLIs are represented as one live installation.** `agents view` no longer invents version-home rows for single-binary installers such as Droid, Grok, Cursor, Kiro, Goose, and Hermes; it reports the version returned by the installed binary and folds away stale per-version directories. `agents add <agent>@<version>` now installs or keeps that agent's current release instead of rejecting an unsupported pinned install. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/versions.ts`, `apps/cli/src/commands/{versions,view}.ts`. (RUSH-1321)
@@ -19,7 +36,6 @@
 - **Wire allowlist support for Cursor CLI.** Cursor agent CLI stores allow/deny in `~/.cursor/cli-config.json` (`permissions.allow`/`deny` with Shell/Read/Write/WebFetch/Mcp). Flip `allowlist: true`, add `convertToCursorFormat` (Bash→Shell), and write via `applyPermissionsToVersion` + detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`. (RUSH-1387)
 - **GitHub Copilot CLI subagents now sync (RUSH-1390).** Installed subagents flatten into GitHub Copilot custom-agent profiles at `~/.copilot/agents/<name>.agent.md` (the Droid custom-droid format), gated to Copilot CLI ≥ 0.0.353. `agents subagents list/view` now surfaces synced Copilot agents and `agents subagents remove` soft-deletes their `.agent.md` files to trash — both previously skipped `copilot` entirely. Source: `apps/cli/src/lib/subagents.ts` (`listSubagentsForAgent`, `removeSubagentFromVersion`, `transformSubagentForCopilot`), `apps/cli/src/lib/staleness/writers/subagents.ts`, `apps/cli/src/lib/staleness/detectors/subagents.ts`, `apps/cli/src/lib/agents.ts`.
 - **Menu-bar Quick Dispatch preserves typed drafts when focus is stolen (RUSH-1592).** If another app activates while the `Cmd-Shift-O` capture panel is open, the panel can hide without destroying the note; the next summon restores the draft text plus selected screenshots, action, and agents. Return submits and clears the draft; Escape clears without dispatching. Source: `apps/cli/menubar/Sources/MenubarHelper/PromptPanel.swift`, `apps/cli/docs/menubar.md`.
-- **Wire subagents support for Kiro CLI.** Kiro custom agents are JSON files under `~/.kiro/agents/*.json` (introduced in kiro-cli v1.23.0). Flip Kiro's `subagents: { since: '1.23.0' }`, add `transformSubagentForKiro`, and wire the subagents writer, detector, install/remove, and orphan-detection paths. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/staleness/{writers,detectors}/subagents.ts`. (RUSH-1393)
 - **Menu-bar ticket agents now carry every selected screenshot into the Linear issue (RUSH-1668).** `Cmd-Shift-O` already passed selected file paths to the ticket agent, but the prompt only asked it to inspect them, so agents could create text-only issues and stop. The brief now identifies every selected path as user-provided ticket material, requires each file to be uploaded, supplies the existing `linear update <id> --proof <path>` path as a reliable default, and leaves description/comment/other placement to the agent's judgment. Source: `apps/cli/menubar/Sources/MenubarHelper/{AgentsCLI,IssueSelfTest}.swift`, `apps/cli/docs/menubar.md`.
 - **`agents sessions --active --json` now carries session attachment metadata for Factory previews (RUSH-1524).** Claude and Droid prompt image/document blocks that reference local files are preserved as `{ path, name, mediaType, sizeBytes }`, and the active-session state dedupes them into `attachments` so consumers can render screenshot thumbnails and open the original files instead of only seeing an attachment count. Source: `apps/cli/src/lib/session/parse.ts`, `apps/cli/src/lib/session/state.ts`, `apps/cli/src/lib/session/active.ts`.
 - **Retired the standalone `com.phnx-labs.agents-secrets-agent` launchd service — the always-on daemon is now the sole broker host (#416, step 2).** `ensureAgentRunning()` no longer installs a separate launchd service: it retires any leftover plist via the new `retireLegacySecretsAgentService()` and relies on the daemon (Path 0), with a one-off detached broker as the only fallback. The upgrade migration (`scripts/postinstall.js` → `healLongRunningProcesses`) now `launchctl bootout`s the legacy service **first**, then (re)starts the daemon so it takes over the broker socket, instead of kickstarting the old service onto new code. `agents secrets start` is now a thin alias that brings the daemon up (and waits for the broker to answer); `agents secrets stop` locks all bundles and retires any leftover legacy service while leaving the always-on daemon running; `agents secrets status` reports broker reachability (daemon-hosted vs standalone) rather than "service installed". The stale broker teardown (version-skew self-heal) retires the legacy service instead of kickstarting it. Source: `apps/cli/src/lib/secrets/agent.ts` (`retireLegacySecretsAgentService`, `ensureAgentRunning`, `teardownStaleBroker`, `uninstallSecretsAgentService`; removed `installSecretsAgentService`/`kickstartSecretsAgentService`/`generateServicePlist`), `apps/cli/scripts/postinstall.js` (`healLongRunningProcesses`), `apps/cli/src/commands/secrets.ts` (`start`/`stop`/`status`).

package/README.md

@@ -161,9 +161,11 @@ Supports plan (read-only), edit, auto, and skip modes, effort levels, JSON outpu
 
 Treat `skip` as a last-resort escape hatch. In direct-exec runs (without `--acp`),
 agents-cli forwards the harness's native no-prompt flag; it does not add another
-safety layer. Prefer `auto` where the harness has a smart classifier (Claude Code and
-GitHub Copilot), or `edit` everywhere else. Harnesses without a native bypass flag
-reject direct-exec `skip`.
+safety layer. Prefer `auto` where it adds a safer automatic policy (smart classifier
+on Claude/Copilot, native high-auto mode on Droid, or interactive Kimi), or `edit`
+everywhere else. For headless Kimi, `edit`, `auto`, and `skip` all use the same
+already-auto-approved `-p` behavior, so prefer `edit` rather than signaling a blanket
+bypass. Harnesses without a native bypass flag reject direct-exec `skip`.
 
 | Harness | Direct-exec `--mode skip` becomes |
 |---|---|
@@ -179,8 +181,9 @@ reject direct-exec `skip`.
 | Droid | `--skip-permissions-unsafe` |
 
 With `--acp`, these native flags are not used. agents-cli instead grants `skip`
-permission requests at the ACP protocol layer with `allow_always`; the same
-last-resort warning applies.
+permission requests at the ACP protocol layer: it selects `allow_always` when offered,
+otherwise the first permission option offered by the server. The same last-resort
+warning applies.
 
 Codex has no native smart-classifier mode, so `agents run codex --mode auto` resolves
 to sandboxed `edit` and can still prompt. `agents run codex --mode skip` is different:
@@ -852,7 +855,7 @@ Which DotAgents resources each agent CLI can load. Source of truth: [src/lib/age
 | Grok Build | yes | yes | yes | yes | yes | skills ($name) | yes | no | `AGENTS.md` | no |
 | OpenClaw | yes | yes | yes | no | yes | gateway | yes | yes | `workspace/AGENTS.md` | no |
 | Cursor | yes | no | yes | no | yes | yes | no | no | `.cursorrules` | no |
-| OpenCode | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
+| OpenCode | yes | no | yes | >= 1.1.1 | yes | yes | no | no | `AGENTS.md` | no |
 | Copilot | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
 | Amp | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
 | Kiro | yes | no | yes | >= 2.8.0 | yes | yes | no | >= 1.23.0 | `AGENTS.md` | no |

package/dist/commands/exec.js

@@ -482,6 +482,7 @@ export function registerRunCommand(program) {
             const { resolveHost, resolveHostByCap } = await import('../lib/hosts/registry.js');
             const { dispatchToHost, runInteractiveOnHost } = await import('../lib/hosts/dispatch.js');
             const { registerHostSession, registerInteractiveHostSession } = await import('../lib/hosts/session-index.js');
+            const { normalizeRunStrategy, RUN_STRATEGIES } = await import('../lib/rotate.js');
             // A password-auth device throws DeviceOffloadUnsupportedError here; it's
             // printed cleanly by the top-level catch in index.ts (covers every
             // resolveHost caller), so it never falls through to capability routing.
@@ -506,12 +507,30 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
             try {
-                const runAgent = agentSpec.split('@')[0];
+                const [runAgent, rawRunVersion] = agentSpec.split('@');
+                // Forward the explicit @version pin verbatim. Resolving aliases like
+                // @latest locally would check local installs, but the remote host may
+                // have versions the laptop does not. The remote agents CLI resolves
+                // aliases against its own installed versions.
+                const runVersion = rawRunVersion || undefined;
+                // Normalize the effective strategy exactly like the local path so we
+                // fail fast on invalid input and can forward --balanced/--strategy.
+                const explicitStrategy = options.strategy ? normalizeRunStrategy(options.strategy) : null;
+                if (options.strategy && !explicitStrategy) {
+                    console.error(chalk.red(`Invalid strategy: ${options.strategy}. Use ${RUN_STRATEGIES.join(', ')}.`));
+                    process.exit(1);
+                }
+                if (options.balanced && explicitStrategy && explicitStrategy !== 'balanced') {
+                    console.error(chalk.red('--balanced conflicts with --strategy. Use one strategy override.'));
+                    process.exit(1);
+                }
+                const runStrategy = options.balanced ? 'balanced' : explicitStrategy ?? undefined;
                 // Working directory on the host: an explicit --remote-cwd is used
                 // verbatim; --cwd/--project are made portable (a local-home absolute
                 // becomes `~/…` so the remote shell re-roots it at ITS home).
                 const { toRemotePortable } = await import('../lib/project-root.js');
                 const hostCwd = options.remoteCwd ?? (options.cwd ? toRemotePortable(options.cwd) : undefined);
+                const hostAddDirs = options.addDir.length > 0 ? options.addDir.map(toRemotePortable) : undefined;
                 // `--resume [id]`: commander yields the string id, or `true` when the
                 // flag is passed bare. A bare resume needs the interactive picker,
                 // which can't run over a detached remote dispatch — only forward a
@@ -549,9 +568,18 @@ export function registerRunCommand(program) {
                     }
                     const exitCode = await runInteractiveOnHost(host, {
                         agent: runAgent,
+                        version: resumeId ? undefined : runVersion,
+                        strategy: resumeId ? undefined : runStrategy,
                         prompt,
                         mode: options.mode,
                         model: options.model,
+                        effort: options.effort,
+                        addDir: hostAddDirs,
+                        json: options.json,
+                        verbose: options.verbose,
+                        timeout: options.timeout,
+                        yes: options.yes,
+                        acp: options.acp,
                         remoteCwd: hostCwd,
                         sessionId: hostSessionId,
                         name: options.name,
@@ -571,9 +599,18 @@ export function registerRunCommand(program) {
                 const hostSessionId = runAgent === 'claude' && !resumeId ? randomUUID() : undefined;
                 const { task, exitCode } = await dispatchToHost(host, {
                     agent: runAgent,
+                    version: resumeId ? undefined : runVersion,
+                    strategy: resumeId ? undefined : runStrategy,
                     prompt,
                     mode: options.mode,
                     model: options.model,
+                    effort: options.effort,
+                    addDir: hostAddDirs,
+                    json: options.json,
+                    verbose: options.verbose,
+                    timeout: options.timeout,
+                    yes: options.yes,
+                    acp: options.acp,
                     remoteCwd: hostCwd,
                     sessionId: hostSessionId,
                     name: options.name,

package/dist/commands/routines.js

@@ -347,6 +347,7 @@ export function registerRoutinesCommands(program) {
         .option('--at <time>', 'One-shot mode: run once at this time (e.g., "14:30" or "2026-02-24 09:00"), then disable')
         .option('--end-at <iso>', 'Stop firing on or after this ISO 8601 timestamp (e.g., "2026-12-31T23:59:00Z"); routine auto-disables.')
         .option('--disabled', 'Create the routine but keep it paused (enable later with resume)')
+        .option('--resume <sessionId>', 'At fire time, resume this existing session id (via `agents run <agent> --resume`) instead of starting fresh — the actual session reopens with full context and the prompt becomes its next turn. Powers self-scheduled wake-ups (e.g. /hibernate). Requires --agent claude or codex; runs un-sandboxed (the session store lives in the real home, not the job overlay).')
         .action(async (nameOrPath, options) => {
         // Check if inline mode (has flags) or file mode
         const hasInlineFlags = options.schedule || options.agent || options.workflow || options.prompt || options.at;
@@ -406,6 +407,7 @@ export function registerRoutinesCommands(program) {
                 ...(devices ? { devices } : {}),
                 ...(runOnce ? { runOnce: true } : {}),
                 ...(options.endAt ? { endAt: options.endAt } : {}),
+                ...(options.resume ? { resume: options.resume } : {}),
             };
             const errors = validateJob(config);
             if (errors.length > 0) {

package/dist/lib/agents.js

@@ -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',
@@ -419,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: { since: '1.25.0' }, 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
@@ -448,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: { since: '1.0.6' }, memory: false, modes: ['edit', 'skip'], rulesImports: false }, // workflows: markdown files in the shared, HOME-global ~/.gemini/config/global_workflows/ (agy scans it at startup; not version-isolated — see workflows.ts), invoked as /<name> slash commands
     },
     // 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
@@ -522,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,
@@ -1022,6 +1024,64 @@ async function antigravityKeychainSignedIn() {
     }
     return cachedAgyKeychainSignedIn;
 }
+/**
+ * OpenCode (sst/opencode) stores provider credentials in a single JSON file at
+ * `$XDG_DATA_HOME/opencode/auth.json`, defaulting to
+ * `~/.local/share/opencode/auth.json` on EVERY platform — its `xdg-basedir`
+ * dependency does not special-case macOS, so there is no
+ * `~/Library/Application Support` variant. The path is account-global (not
+ * per-version), matching how `session/discover.ts` already resolves
+ * `~/.local/share/opencode/opencode.db`.
+ *
+ * Resolution order, first existing wins:
+ *   1. `<base>/.local/share/opencode/auth.json` — the passed per-version home.
+ *      This is primarily a test hook (suites write a hermetic auth file under a
+ *      temp home) but also covers any relocated install.
+ *   2. `$XDG_DATA_HOME/opencode/auth.json` — an explicit XDG override, exactly
+ *      what OpenCode itself honours.
+ *   3. `<realHome>/.local/share/opencode/auth.json` — the active default, under
+ *      `AGENTS_REAL_HOME` or `os.homedir()`, so every installed version reflects
+ *      the one account-global login (same fallback shape as
+ *      resolveAccountCredentialPath).
+ * Returns the first existing path, or null. Never throws.
+ */
+function resolveOpenCodeAuthPath(base) {
+    const candidates = [path.join(base, '.local', 'share', 'opencode', 'auth.json')];
+    const xdgData = process.env.XDG_DATA_HOME;
+    if (xdgData)
+        candidates.push(path.join(xdgData, 'opencode', 'auth.json'));
+    const realHome = process.env.AGENTS_REAL_HOME || os.homedir();
+    candidates.push(path.join(realHome, '.local', 'share', 'opencode', 'auth.json'));
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        catch { /* unreadable */ }
+    }
+    return null;
+}
+/**
+ * Validate one OpenCode auth.json entry against its discriminated union
+ * (`type: 'oauth' | 'api' | 'wellknown'`) and confirm the credential actually
+ * carries its required secret field(s) non-empty. This guards against a
+ * corrupt/half-written entry reading as signed-in — the same "must have a real
+ * credential" floor grok/antigravity apply. We only INSPECT the shape here; the
+ * secret values (`access`/`refresh`/`key`/`token`) are never read out or
+ * surfaced anywhere.
+ */
+function isValidOpenCodeCredential(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const cred = value;
+    const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+    switch (cred.type) {
+        case 'oauth': return nonEmpty(cred.access) || nonEmpty(cred.refresh);
+        case 'api': return nonEmpty(cred.key);
+        case 'wellknown': return nonEmpty(cred.key) && nonEmpty(cred.token);
+        default: return false;
+    }
+}
 export async function getAccountInfo(agentId, home) {
     const base = home || os.homedir();
     const empty = {
@@ -1251,6 +1311,34 @@ export async function getAccountInfo(agentId, home) {
                     return { ...empty, lastActive };
                 return { ...empty, signedIn: true, lastActive };
             }
+            case 'opencode': {
+                // OpenCode's auth.json is a record keyed by provider id ->
+                // { type: 'oauth'|'api'|'wellknown', ...secret fields }. There is no
+                // email/identity claim to surface, so — like antigravity/kimi — we
+                // report signed-in state plus the NON-SECRET provider metadata (which
+                // provider ids hold a valid credential) and never read the tokens/keys
+                // themselves. The user's complaint was the row read "not signed in"
+                // despite a live login; a valid provider entry now shows e.g.
+                // "id:muse-spark" so they can see exactly which provider is configured.
+                const authPath = resolveOpenCodeAuthPath(base);
+                if (!authPath)
+                    return { ...empty, lastActive };
+                const data = JSON.parse(await fs.promises.readFile(authPath, 'utf-8'));
+                if (!data || typeof data !== 'object')
+                    return { ...empty, lastActive };
+                const providers = Object.entries(data)
+                    .filter(([, cred]) => isValidOpenCodeCredential(cred))
+                    .map(([id]) => id)
+                    .sort();
+                if (providers.length === 0)
+                    return { ...empty, lastActive };
+                // Provider ids are config keys (e.g. "anthropic", "muse-spark"), not
+                // secrets. Join them into a stable, human-readable account label +
+                // identity key for usage dedup.
+                const accountId = providers.join('+');
+                const accountKey = buildIdentityKey(agentId, [['providers', accountId]]);
+                return { ...empty, signedIn: true, accountId, accountKey, lastActive };
+            }
             default:
                 return { ...empty, lastActive };
         }

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/permissions.d.ts

@@ -106,15 +106,15 @@ 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. */
@@ -140,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