@phnx-labs/agents-cli 1.20.60 → 1.20.61

package/CHANGELOG.md

@@ -2,11 +2,15 @@
 
 ## Unreleased
 
-## 1.20.60
+## 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 remain disabled for version-home sync until a global filesystem target is documented. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/workflows.ts`.
+- **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`.

package/README.md

@@ -855,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/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

@@ -450,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: { since: '1.0.16' }, 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
@@ -1024,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 = {
@@ -1253,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/routines.d.ts

@@ -75,6 +75,13 @@ export interface JobConfig {
     version?: string;
     runOnce?: boolean;
     endAt?: string;
+    /**
+     * When set, the job resumes this existing agent session id at fire time
+     * (`agents run <agent> --resume <id>`) instead of starting a fresh conversation,
+     * so the actual session reopens with full context and `prompt` becomes its next
+     * turn. Powers self-scheduled wake-ups (e.g. /hibernate). claude/codex only.
+     */
+    resume?: string;
     /** When set, executeJob runs this job through the loop driver instead of once. */
     loop?: LoopConfig;
 }

package/dist/lib/routines.js

@@ -298,6 +298,24 @@ export function validateJob(config) {
             errors.push('workflow must be a lowercase alphanumeric name (hyphens and underscores allowed, e.g. autodev)');
         }
     }
+    if (config.resume !== undefined) {
+        // Only claude/codex support native `--resume`; other agents would emit a resume
+        // flag they don't understand. Resume reopens an agent session, so it is
+        // incompatible with workflow and loop jobs (which have no single session to reopen).
+        const RESUMABLE_AGENTS = ['claude', 'codex'];
+        if (typeof config.resume !== 'string' || config.resume.trim() === '') {
+            errors.push('resume must be a non-empty session id string');
+        }
+        if (hasWorkflow) {
+            errors.push('resume cannot be combined with workflow (resume reopens an existing agent session)');
+        }
+        if (config.loop) {
+            errors.push('resume cannot be combined with loop');
+        }
+        if (hasAgent && config.agent && !RESUMABLE_AGENTS.includes(config.agent)) {
+            errors.push(`resume is only supported for agents with native --resume (${RESUMABLE_AGENTS.join(', ')}); got '${config.agent}'`);
+        }
+    }
     if (config.mode && !['plan', 'edit', 'auto', 'skip', 'full'].includes(config.mode)) {
         errors.push("mode must be plan, edit, auto, or skip ('full' accepted as alias for skip)");
     }

package/dist/lib/runner.d.ts

@@ -50,6 +50,13 @@ export declare function resolveRoutineLaunch(config: JobConfig, cwd?: string): P
  * surface as "agents: no version of X configured".
  */
 export declare function pinJobBinary(cmd: string[], agent: AgentId, version: string | undefined): string[];
+/**
+ * Whether a job's command is dispatched through `agents run` (so `cmd[0] === 'agents'`)
+ * rather than the agent binary directly. True for workflow jobs and for resume jobs.
+ * Such commands must NOT be binary-pinned (pinning rewrites cmd[0] to the agent binary,
+ * producing a broken `<binary> run …`) and must not receive a version-pinned spawn env.
+ */
+export declare function dispatchesViaAgentsRun(config: Pick<JobConfig, 'workflow' | 'resume'>): boolean;
 /**
  * Merge sandbox/base env with the canonical per-version exec env
  * (CLAUDE_CONFIG_DIR / CODEX_HOME / …) so routines share account isolation

package/dist/lib/runner.js

@@ -44,6 +44,14 @@ export function buildJobCommand(config, resolvedPrompt) {
         const cmd = ['agents', 'run', config.workflow, resolvedPrompt, '--mode', config.mode];
         return cmd;
     }
+    // Resume branch: reopen an EXISTING session via `agents run <agent> --resume <id>`
+    // instead of starting fresh. The real session resumes with its full prior context
+    // (index-based lookup, cwd-independent) and `resolvedPrompt` becomes its next turn —
+    // so a self-scheduled wake (e.g. /hibernate) is handled by the session that scheduled
+    // it, not a fresh, context-less agent that would refuse an "opaque" instruction.
+    if (config.resume) {
+        return ['agents', 'run', config.agent, '--resume', config.resume, resolvedPrompt, '--mode', config.mode];
+    }
     const template = AGENT_COMMANDS[config.agent];
     if (!template) {
         throw new Error(`Unsupported agent for daemon jobs: ${config.agent}`);
@@ -263,6 +271,15 @@ export function pinJobBinary(cmd, agent, version) {
     next[0] = binary;
     return next;
 }
+/**
+ * Whether a job's command is dispatched through `agents run` (so `cmd[0] === 'agents'`)
+ * rather than the agent binary directly. True for workflow jobs and for resume jobs.
+ * Such commands must NOT be binary-pinned (pinning rewrites cmd[0] to the agent binary,
+ * producing a broken `<binary> run …`) and must not receive a version-pinned spawn env.
+ */
+export function dispatchesViaAgentsRun(config) {
+    return Boolean(config.workflow || config.resume);
+}
 /**
  * Merge sandbox/base env with the canonical per-version exec env
  * (CLAUDE_CONFIG_DIR / CODEX_HOME / …) so routines share account isolation
@@ -394,7 +411,11 @@ export async function executeJob(config, deps) {
         schedule: config.schedule,
     });
     const resolvedPrompt = resolveJobPrompt(config);
-    const useSandbox = config.sandbox !== false;
+    // Resume must run against the REAL home: `--resume <id>` resolves the session from
+    // the agent's config dir, and the sandbox overlay home has only a freshly-generated
+    // config with no session store. So a resume job is never sandboxed, regardless of
+    // `config.sandbox` (see the resume branch in buildJobCommand).
+    const useSandbox = config.sandbox !== false && !config.resume;
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = generateRunId();
     const runDir = getRunDir(config.name, runId);
@@ -470,10 +491,11 @@ export async function executeJob(config, deps) {
         if (i === 0) {
             process.stderr.write(`[agents] routine ${config.name}: running ${label}\n`);
         }
-        const cmd = config.workflow
+        const viaAgentsRun = dispatchesViaAgentsRun(config);
+        const cmd = viaAgentsRun
             ? baseCmd
             : pinJobBinary(baseCmd, attemptAgent, attemptVersion);
-        const spawnEnv = config.workflow
+        const spawnEnv = viaAgentsRun
             ? (() => {
                 const e = { ...baseEnv };
                 if (config.timezone)
@@ -553,10 +575,16 @@ export async function executeJobDetached(config) {
     const version = launch.chain[0]?.version ?? config.version;
     const resolvedPrompt = resolveJobPrompt(config);
     let cmd = buildJobCommand(config, resolvedPrompt);
-    if (!config.workflow && version) {
+    // workflow AND resume dispatch through `agents run` — never binary-pin them (pinning
+    // rewrites cmd[0] to the agent binary → broken `<binary> run …`).
+    if (!dispatchesViaAgentsRun(config) && version) {
         cmd = pinJobBinary(cmd, config.agent, version);
     }
-    const useSandbox = config.sandbox !== false;
+    // Resume must run against the REAL home: `--resume <id>` resolves the session from
+    // the agent's config dir, and the sandbox overlay home has only a freshly-generated
+    // config with no session store. So a resume job is never sandboxed, regardless of
+    // `config.sandbox` (see the resume branch in buildJobCommand).
+    const useSandbox = config.sandbox !== false && !config.resume;
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = generateRunId();
     const runDir = getRunDir(config.name, runId);
@@ -566,7 +594,7 @@ export async function executeJobDetached(config) {
     const baseEnv = useSandbox
         ? buildSpawnEnv(overlayHome)
         : { ...process.env };
-    const spawnEnv = config.workflow
+    const spawnEnv = dispatchesViaAgentsRun(config)
         ? (() => {
             const e = { ...baseEnv };
             if (config.timezone)

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

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

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

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

package/dist/lib/tmux/session.js

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

package/dist/lib/versions.js

@@ -1148,6 +1148,72 @@ export function setGlobalDefault(agent, version) {
     }
     writeMeta(meta);
 }
+/**
+ * Grok's official installer writes into ~/.grok/downloads, which (because we
+ * symlink ~/.grok to the active version home) resolves to the PREVIOUS default
+ * home during `agents add grok@<new>`. Move the freshly-downloaded binary and
+ * its generic platform copy into the target version's isolated home so
+ * `listInstalledVersions` and the shim resolve the right binary.
+ */
+function relocateGrokBinaryToVersionHome(installedVersion) {
+    const hostGrokLink = path.join(getHomeDir(), agentConfigDirName('grok'));
+    let sourceDownloads;
+    try {
+        sourceDownloads = path.join(fs.readlinkSync(hostGrokLink), 'downloads');
+    }
+    catch {
+        sourceDownloads = path.join(hostGrokLink, 'downloads');
+    }
+    const targetDownloads = path.join(getVersionHomePath('grok', installedVersion), agentConfigDirName('grok'), 'downloads');
+    if (!fs.existsSync(sourceDownloads))
+        return;
+    if (path.resolve(sourceDownloads) === path.resolve(targetDownloads))
+        return;
+    const entries = fs.readdirSync(sourceDownloads).filter((e) => e.startsWith('grok-'));
+    if (entries.length === 0)
+        return;
+    fs.mkdirSync(targetDownloads, { recursive: true });
+    const escapedVersion = installedVersion.replace(/\./g, '\\.');
+    const versionedPattern = new RegExp(`^grok-${escapedVersion}-`);
+    const movedPaths = [];
+    // Move the versioned binary first.
+    for (const entry of entries) {
+        if (!versionedPattern.test(entry))
+            continue;
+        const src = path.join(sourceDownloads, entry);
+        const dst = path.join(targetDownloads, entry);
+        if (fs.existsSync(dst))
+            continue;
+        try {
+            fs.renameSync(src, dst);
+            movedPaths.push(dst);
+        }
+        catch {
+            /* ignore per-file failures */
+        }
+    }
+    if (movedPaths.length === 0)
+        return;
+    // The installer also creates a generic platform binary (e.g. grok-macos-aarch64)
+    // that is a copy of the versioned binary. Move it too if its size matches.
+    const movedSize = fs.statSync(movedPaths[0]).size;
+    for (const entry of entries) {
+        if (versionedPattern.test(entry))
+            continue; // already handled
+        const src = path.join(sourceDownloads, entry);
+        const dst = path.join(targetDownloads, entry);
+        if (fs.existsSync(dst))
+            continue;
+        try {
+            if (fs.statSync(src).size === movedSize) {
+                fs.renameSync(src, dst);
+            }
+        }
+        catch {
+            /* ignore per-file failures */
+        }
+    }
+}
 /**
  * Install a specific version of an agent.
  */
@@ -1204,6 +1270,12 @@ export async function installVersion(agent, version, onProgress, opts) {
         const versionDir = getVersionDir(agent, installedVersion);
         fs.mkdirSync(versionDir, { recursive: true });
         fs.mkdirSync(path.join(versionDir, 'home'), { recursive: true });
+        // Grok's installer drops the binary into ~/.grok/downloads, which currently
+        // resolves to the PREVIOUS default home. Move it into the target version home
+        // so version isolation is correct.
+        if (agent === 'grok') {
+            relocateGrokBinaryToVersionHome(installedVersion);
+        }
         // Symlink the installed binary into the version's node_modules/.bin so
         // listInstalledVersions (which checks getBinaryPath) sees this version as
         // installed. Without this, `agents add antigravity@latest` succeeds

package/dist/lib/workflows.d.ts

@@ -265,6 +265,15 @@ export declare function pruneStaleWorkflowSubagents(sharedAgentsDir: string, wor
 export declare function countWorkflowSubagents(workflowDir: string): number;
 /** Convert a canonical agents-cli workflow bundle into a Kimi flow skill. */
 export declare function transformWorkflowForKimi(workflowPath: string, name: string): string;
+/**
+ * Convert a canonical agents-cli workflow bundle into an Antigravity workflow
+ * markdown file. Antigravity discovers workflows as flat `<name>.md` files under
+ * `~/.gemini/config/global_workflows/` (scanned by `agy` at startup) and exposes
+ * each as a `/<name>` slash command. Frontmatter carries the required `description`
+ * plus the shared `agents_workflow` ownership marker so agents-cli never clobbers a
+ * user-authored workflow of the same name.
+ */
+export declare function transformWorkflowForAntigravity(workflowPath: string, name: string): string;
 /**
  * Resolve an `agents run <workflow>` reference.
  *

package/dist/lib/workflows.js

@@ -6,6 +6,7 @@
  * are composed at runtime by `agents run <workflow>`.
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { capableAgents } from './capabilities.js';
@@ -369,6 +370,26 @@ export function transformWorkflowForKimi(workflowPath, name) {
     const instructions = (body || fm.description).trim();
     return `---\n${frontmatter}\n---\n\n\`\`\`d2\nBEGIN -> step -> END\nstep: |md\n${indentD2BlockString(instructions)}\n|\n\`\`\`\n`;
 }
+/**
+ * Convert a canonical agents-cli workflow bundle into an Antigravity workflow
+ * markdown file. Antigravity discovers workflows as flat `<name>.md` files under
+ * `~/.gemini/config/global_workflows/` (scanned by `agy` at startup) and exposes
+ * each as a `/<name>` slash command. Frontmatter carries the required `description`
+ * plus the shared `agents_workflow` ownership marker so agents-cli never clobbers a
+ * user-authored workflow of the same name.
+ */
+export function transformWorkflowForAntigravity(workflowPath, name) {
+    const fm = parseWorkflowFrontmatter(workflowPath);
+    if (!fm)
+        throw new Error(`Invalid WORKFLOW.md in ${workflowPath}`);
+    const body = getWorkflowBody(workflowPath) || fm.description;
+    const frontmatter = yaml.stringify({
+        description: fm.description,
+        name: fm.name || name,
+        [KIMI_WORKFLOW_MARKER]: name,
+    }).trim();
+    return `---\n${frontmatter}\n---\n\n${body.trim()}\n`;
+}
 function expandWorkflowPath(ref) {
     if (ref === '~')
         return process.env.HOME ?? ref;
@@ -527,9 +548,24 @@ export function removeWorkflow(name) {
         return { success: false, error: err.message };
     }
 }
+/**
+ * Antigravity user workflows are NOT version-isolated. `agy` scans a single,
+ * shared, HOME-global directory at startup — `~/.gemini/config/global_workflows/`
+ * — and that dir is a real directory in the user's home, never symlinked into a
+ * per-version home (only `~/.gemini/antigravity-cli` is version-scoped). Writing
+ * into a version home therefore lands somewhere agy never reads. So every
+ * antigravity version resolves to the same real shared dir; `versionHome` is
+ * intentionally ignored. (Verified via strace of `agy`: it opens
+ * `$HOME/.gemini/config/global_workflows/<name>.md` and never the version home.)
+ */
+function antigravityWorkflowsDir() {
+    return path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
+}
 function workflowTargetRoot(agent, versionHome) {
     if (agent === 'kimi')
         return path.join(versionHome, '.kimi-code', 'skills');
+    if (agent === 'antigravity')
+        return antigravityWorkflowsDir();
     return path.join(versionHome, 'workflows');
 }
 /** List workflow names synced into a specific agent version home. */
@@ -543,6 +579,20 @@ export function listWorkflowsForAgent(agent, versionHome) {
             .filter(d => kimiWorkflowMarker(path.join(skillsDir, d.name, 'SKILL.md')) === d.name)
             .map(d => d.name);
     }
+    if (agent === 'antigravity') {
+        const dir = workflowTargetRoot(agent, versionHome);
+        if (!fs.existsSync(dir))
+            return [];
+        try {
+            return fs.readdirSync(dir, { withFileTypes: true })
+                .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
+                .map(d => d.name.slice(0, -'.md'.length))
+                .filter(base => antigravityWorkflowMarker(path.join(dir, `${base}.md`)) === base);
+        }
+        catch {
+            return [];
+        }
+    }
     if (agent === 'goose') {
         const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
         if (!fs.existsSync(recipesDir))
@@ -678,7 +728,17 @@ export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
             return { success: true };
         }
         if (agent === 'antigravity') {
-            return { success: false, error: 'Antigravity workflow sync is not supported for version homes' };
+            const targetDir = workflowTargetRoot(agent, versionHome);
+            const targetFile = path.join(targetDir, `${name}.md`);
+            if (fs.existsSync(targetFile)) {
+                const marker = antigravityWorkflowMarker(targetFile);
+                if (marker !== name) {
+                    return { success: false, error: `Antigravity workflow '${name}' already exists and is not managed by agents-cli` };
+                }
+            }
+            fs.mkdirSync(targetDir, { recursive: true });
+            fs.writeFileSync(targetFile, transformWorkflowForAntigravity(workflowPath, name), 'utf-8');
+            return { success: true };
         }
         const targetDir = path.join(workflowTargetRoot(agent, versionHome), name);
         fs.mkdirSync(workflowTargetRoot(agent, versionHome), { recursive: true });
@@ -696,7 +756,20 @@ export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
 export function removeWorkflowFromVersion(agent, version, name) {
     const versionHome = getVersionHomePath(agent, version);
     if (agent === 'antigravity') {
-        return { success: false, error: 'Antigravity workflow sync is not supported for version homes' };
+        const targetFile = path.join(workflowTargetRoot(agent, versionHome), `${name}.md`);
+        if (!fs.existsSync(targetFile)) {
+            return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
+        }
+        if (antigravityWorkflowMarker(targetFile) !== name) {
+            return { success: false, error: `Antigravity workflow '${name}' is not managed by agents-cli` };
+        }
+        try {
+            fs.rmSync(targetFile, { force: true });
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err.message };
+        }
     }
     if (agent === 'goose') {
         const recipePath = path.join(versionHome, '.config', 'goose', 'recipes', `${name}.yaml`);
@@ -754,6 +827,15 @@ function kimiWorkflowMarker(filePath) {
         return null;
     }
 }
+function antigravityWorkflowMarker(filePath) {
+    try {
+        const fm = parseSkillFrontmatter(filePath);
+        return typeof fm?.agents_workflow === 'string' ? fm.agents_workflow : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Iterate all installed (agent, version) pairs that support workflows. */
 export function iterWorkflowsCapableVersions(filter) {
     const result = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.60",
+  "version": "1.20.61",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",