@phnx-labs/agents-cli 1.20.77 → 1.20.82

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

@@ -6,7 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { AGENTS, MANAGED_AGENT_IDS, agentConfigDirName } from '../../agents.js';
 import { shouldInstallCommandAsSkill, listCommandSkillsInVersion } from '../../command-skills.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildCommandsDetector(agent) {
@@ -34,7 +34,7 @@ function buildCommandsDetector(agent) {
 // agents with their own slash-command runtime (nativeCommandRuntime) opt out.
 export const commandsDetectors = lazyAgentMap(() => {
     const m = {};
-    for (const id of Object.keys(AGENTS)) {
+    for (const id of MANAGED_AGENT_IDS) {
         const cfg = AGENTS[id];
         if (cfg.capabilities.commands === false && (!cfg.commandsSubdir || cfg.commandsSubdir === '') && cfg.nativeCommandRuntime)
             continue;

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

@@ -3,7 +3,7 @@
  * reports the permission GROUP names that have been applied.
  *
  * For claude/opencode the detector intersects with discovered groups (a group
- * is "applied" if any of its allow/deny rules are present). For Codex / Gemini /
+ * is "applied" if any of its allow/deny rules are present). For Codex /
  * Antigravity / Grok the on-disk format is lossy — once any group has been
  * applied the storage doesn't carry per-group provenance back, so we report
  * "all known groups applied" when any permission artifact is present. This
@@ -100,29 +100,6 @@ function buildOpenCodeDetector() {
         },
     };
 }
-function buildGeminiDetector() {
-    return {
-        kind: 'permissions',
-        agent: 'gemini',
-        list({ versionHome }) {
-            const settingsPath = path.join(versionHome, '.gemini', 'settings.json');
-            if (!fs.existsSync(settingsPath))
-                return [];
-            try {
-                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                const core = settings?.tools?.core;
-                const exclude = settings?.tools?.exclude;
-                const hasCore = Array.isArray(core) && core.length > 0;
-                const hasExclude = Array.isArray(exclude) && exclude.length > 0;
-                if (hasCore || hasExclude) {
-                    return discoverPermissionGroups().map(g => g.name);
-                }
-            }
-            catch { /* parse fail */ }
-            return [];
-        },
-    };
-}
 function buildAntigravityDetector() {
     return {
         kind: 'permissions',
@@ -312,25 +289,6 @@ function buildCopilotDetector() {
         },
     };
 }
-function buildForgeDetector() {
-    return {
-        kind: 'permissions',
-        agent: 'forge',
-        list({ versionHome }) {
-            const permissionsPath = path.join(versionHome, '.forge', 'permissions.yaml');
-            if (!fs.existsSync(permissionsPath))
-                return [];
-            try {
-                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
-                if (config && Array.isArray(config.policies) && config.policies.length > 0) {
-                    return discoverPermissionGroups().map(g => g.name);
-                }
-            }
-            catch { /* parse fail */ }
-            return [];
-        },
-    };
-}
 function buildHermesDetector() {
     return {
         kind: 'permissions',
@@ -355,7 +313,6 @@ const handlers = {
     claude: buildClaudeDetector,
     codex: buildCodexDetector,
     opencode: buildOpenCodeDetector,
-    gemini: buildGeminiDetector,
     antigravity: buildAntigravityDetector,
     grok: buildGrokDetector,
     goose: buildGooseDetector,
@@ -365,7 +322,6 @@ const handlers = {
     kiro: buildKiroDetector,
     openclaw: buildOpenClawDetector,
     copilot: buildCopilotDetector,
-    forge: buildForgeDetector,
     hermes: buildHermesDetector,
 };
 export const permissionsDetectors = lazyAgentMap(() => {

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

@@ -11,15 +11,14 @@
  *
  *  - native command file — `{agentDir}/<commandsSubdir>/<name>.md` (or .toml
  *    when the agent's format is toml). Standard path for Claude, Codex
- *    < 0.117.0, Gemini, Cursor, OpenCode, Copilot, Amp, Kiro, Roo,
- *    Antigravity.
+ *    < 0.117.0, Cursor, OpenCode, Copilot, Amp, Kiro, Roo, Antigravity.
  *
  * Source resolution is `resolveCommandSource` (user → system → extras —
  * project layer intentionally excluded).
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { AGENTS, MANAGED_AGENT_IDS, agentConfigDirName } from '../../agents.js';
 import { supports } from '../../capabilities.js';
 import { safeJoin } from '../../paths.js';
 import { markdownToToml } from '../../convert.js';
@@ -83,7 +82,7 @@ function buildCommandsWriter(agent) {
 // Built lazily on first access — see lazy-map.ts for the cycle rationale.
 //
 // Registration covers two cases:
-//   - native commands (claude, codex < 0.117.0, gemini, grok, etc.) — `commands` cap
+//   - native commands (claude, codex < 0.117.0, grok, etc.) — `commands` cap
 //   - commands-as-skills (kimi, codex >= 0.117.0)
 //
 // Agents that have skills but use a NATIVE non-file slash-command system
@@ -92,7 +91,7 @@ function buildCommandsWriter(agent) {
 // commands, so there's nothing to write and nothing to convert.
 export const commandsWriters = lazyAgentMap(() => {
     const m = {};
-    for (const id of Object.keys(AGENTS)) {
+    for (const id of MANAGED_AGENT_IDS) {
         const cfg = AGENTS[id];
         if (cfg.capabilities.commands === false && (!cfg.skillsDir || cfg.skillsDir === ''))
             continue;

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

@@ -90,7 +90,7 @@ function buildHooksWriter(agent) {
             // registerHooksForGrok — file copy alone only sees top-level available.hooks
             // names (RUSH-1353). Copilot/Kiro/Goose load managed *.json under their
             // hooks dirs the same way.
-            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced };

package/dist/lib/startup/command-registry.d.ts

@@ -25,7 +25,6 @@ export type Registrar = (program: Command) => void;
 export type ModuleLoader = () => Promise<Registrar>;
 export declare const loadView: ModuleLoader;
 export declare const loadInspect: ModuleLoader;
-export declare const loadResources: ModuleLoader;
 export declare const loadFeedback: ModuleLoader;
 export declare const loadCommands: ModuleLoader;
 export declare const loadHooks: ModuleLoader;
@@ -48,13 +47,13 @@ export declare const loadMonitors: ModuleLoader;
 export declare const loadRun: ModuleLoader;
 export declare const loadFork: ModuleLoader;
 export declare const loadDefaults: ModuleLoader;
+export declare const loadSet: ModuleLoader;
 export declare const loadModels: ModuleLoader;
 export declare const loadPrune: ModuleLoader;
 export declare const loadTrash: ModuleLoader;
 export declare const loadRestore: ModuleLoader;
 export declare const loadDoctor: ModuleLoader;
 export declare const loadApply: ModuleLoader;
-export declare const loadCheck: ModuleLoader;
 export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
 export declare const loadHarness: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -3,7 +3,6 @@
 // them into the exact main-branch registration order for the slow path.
 export const loadView = async () => (await import('../../commands/view.js')).registerViewCommand;
 export const loadInspect = async () => (await import('../../commands/inspect.js')).registerInspectCommand;
-export const loadResources = async () => (await import('../../commands/resources.js')).registerResourcesCommand;
 export const loadFeedback = async () => (await import('../../commands/feedback.js')).registerFeedbackCommand;
 export const loadCommands = async () => (await import('../../commands/commands.js')).registerCommandsCommands;
 export const loadHooks = async () => (await import('../../commands/hooks.js')).registerHooksCommands;
@@ -26,13 +25,13 @@ export const loadMonitors = async () => (await import('../../commands/monitors.j
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadFork = async () => (await import('../../commands/fork.js')).registerForkCommand;
 export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
+export const loadSet = async () => (await import('../../commands/set.js')).registerSetCommand;
 export const loadModels = async () => (await import('../../commands/models.js')).registerModelsCommand;
 export const loadPrune = async () => (await import('../../commands/prune.js')).registerPruneCommand;
 export const loadTrash = async () => (await import('../../commands/trash.js')).registerTrashCommands;
 export const loadRestore = async () => (await import('../../commands/trash.js')).registerRestoreCommand;
 export const loadDoctor = async () => (await import('../../commands/doctor.js')).registerDoctorCommand;
 export const loadApply = async () => (await import('../../commands/apply.js')).registerApplyCommand;
-export const loadCheck = async () => (await import('../../commands/check.js')).registerCheckCommand;
 export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
 export const loadHarness = async () => (await import('../../commands/harness.js')).registerHarnessCommands;
@@ -107,7 +106,6 @@ export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'messag
 export const COMMAND_LOADERS = {
     view: [loadView],
     inspect: [loadInspect],
-    resources: [loadResources],
     feedback: [loadFeedback],
     commands: [loadCommands],
     hooks: [loadHooks],
@@ -138,12 +136,12 @@ export const COMMAND_LOADERS = {
     run: [loadRun],
     fork: [loadFork],
     defaults: [loadDefaults],
+    set: [loadSet],
     models: [loadModels],
     trash: [loadTrash],
     restore: [loadRestore],
     doctor: [loadDoctor],
     apply: [loadApply],
-    check: [loadCheck],
     status: [loadStatus],
     profile: [loadProfiles],
     profiles: [loadProfiles],

package/dist/lib/subagents-registry.js

@@ -14,8 +14,8 @@
  * every current agent, so most entries are a single call:
  *
  *   - `flatFile`  one `<name><ext>` file, body from a `transform` fn.
- *                 (claude, gemini, grok, droid, codex, opencode, copilot,
- *                  cursor, forge, kiro, goose)
+ *                 (claude, grok, droid, codex, opencode, copilot,
+ *                  cursor, kiro, goose)
  *   - `dirFile`   a `<name>/` directory holding one generated `<file>`.
  *                 (antigravity: `<name>/agent.md`)
  *   - `dirCopy`   copy the whole source directory to `<name>/`, applying
@@ -33,13 +33,13 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { safeJoin } from './paths.js';
-import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForForge, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, } from './subagents.js';
+import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, } from './subagents.js';
 // ── metadata readers (the per-format escape hatch) ───────────────────────────
-/** Frontmatter, skipping files that lack a valid block (claude/gemini/grok/droid/codex). */
+/** Frontmatter, skipping files that lack a valid block (claude/grok/droid/codex). */
 function metaFrontmatterSkip(filePath) {
     return parseSubagentFrontmatter(filePath);
 }
-/** Frontmatter, falling back to an empty description (opencode/copilot/cursor/forge). */
+/** Frontmatter, falling back to an empty description (opencode/copilot/cursor). */
 function metaFrontmatterFallback(filePath, name) {
     return parseSubagentFrontmatter(filePath) ?? { name, description: '' };
 }
@@ -251,7 +251,6 @@ const kimiTarget = {
 export const SUBAGENT_TARGETS = {
     // Tier 1 -- flat markdown, Claude-compatible flatten.
     claude: flatFile({ subdir: ['.claude', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
-    gemini: flatFile({ subdir: ['.gemini', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
     grok: flatFile({ subdir: ['.grok', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
     droid: flatFile({ subdir: ['.factory', 'droids'], ext: '.md', transform: transformSubagentForDroid }),
     // Bespoke frontmatter/format, still one flat file.
@@ -274,12 +273,6 @@ export const SUBAGENT_TARGETS = {
         transform: transformSubagentForCursor,
         readMeta: metaFrontmatterFallback,
     }),
-    forge: flatFile({
-        subdir: ['.forge', 'agents'],
-        ext: '.md',
-        transform: transformSubagentForForge,
-        readMeta: metaFrontmatterFallback,
-    }),
     kiro: flatFile({
         subdir: ['.kiro', 'agents'],
         ext: '.json',

package/dist/lib/subagents.d.ts

@@ -79,16 +79,6 @@ export declare function transformSubagentForCopilot(subagentDir: string): string
  * See https://cursor.com/docs/subagents.
  */
 export declare function transformSubagentForCursor(subagentDir: string): string;
-/**
- * Transform a subagent into a ForgeCode custom subagent `.md` file.
- *
- * ForgeCode loads named agents from `.forge/agents/*.md` (project) or
- * `~/.forge/agents/*.md` (user) — Markdown with YAML frontmatter (id, title,
- * description, tools, model, temperature) + a system-prompt body. ForgeCode has
- * no `color` field, so this is an alias of transformSubagentForDroid, same as
- * Copilot/Cursor. See https://forgecode.dev/docs/agent-definition-guide/.
- */
-export declare function transformSubagentForForge(subagentDir: string): string;
 /**
  * Transform a subagent into Antigravity's custom-agent markdown shape.
  *

package/dist/lib/subagents.js

@@ -290,18 +290,6 @@ export function transformSubagentForCopilot(subagentDir) {
 export function transformSubagentForCursor(subagentDir) {
     return transformSubagentForDroid(subagentDir);
 }
-/**
- * Transform a subagent into a ForgeCode custom subagent `.md` file.
- *
- * ForgeCode loads named agents from `.forge/agents/*.md` (project) or
- * `~/.forge/agents/*.md` (user) — Markdown with YAML frontmatter (id, title,
- * description, tools, model, temperature) + a system-prompt body. ForgeCode has
- * no `color` field, so this is an alias of transformSubagentForDroid, same as
- * Copilot/Cursor. See https://forgecode.dev/docs/agent-definition-guide/.
- */
-export function transformSubagentForForge(subagentDir) {
-    return transformSubagentForDroid(subagentDir);
-}
 /**
  * Transform a subagent into Antigravity's custom-agent markdown shape.
  *

package/dist/lib/teams/agents.d.ts

@@ -56,8 +56,6 @@ export declare const VALID_MODES: readonly ["plan", "edit", "auto", "skip", "ful
 type Mode = 'plan' | 'edit' | 'auto' | 'skip';
 /** Resolve a mode string to a validated Mode, falling back to the given default. */
 export declare function resolveMode(requestedMode: string | null | undefined, defaultMode?: Mode): Mode;
-/** Ensure Gemini's settings.json has experimental.plan enabled for headless plan mode. */
-export declare function ensureGeminiPlanMode(): Promise<void>;
 /**
  * Check whether the CLI binary for a given agent type is installed.
  * Returns [available, pathOrError].

package/dist/lib/teams/agents.js

@@ -3,7 +3,7 @@
  *
  * Defines the AgentProcess and AgentManager classes that handle spawning,
  * monitoring, stopping, and persisting teammate processes across all supported
- * agent CLIs (Claude, Codex, Gemini, Cursor, OpenCode). Supports DAG-based
+ * agent CLIs (Claude, Codex, Cursor, OpenCode). Supports DAG-based
  * dependency scheduling via --after, per-teammate model/effort overrides, and
  * multiple permission modes (plan, edit, full).
  */
@@ -18,7 +18,6 @@ import { resolveAgentsDir } from './persistence.js';
 import { findExecutable, captureProcessStartTime } from '../platform/index.js';
 import { normalizeEvents } from './parsers.js';
 import { debug } from './debug.js';
-import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from '../gemini-settings.js';
 import { getAgentsDir as getSystemAgentsDir, getShimsDir } from '../state.js';
 import { AGENTS, getAccountInfo } from '../agents.js';
 import { resolveVersion, isVersionInstalled, verifyInstalledBinaryLaunches } from '../versions.js';
@@ -196,7 +195,7 @@ export function buildTeammateSpawnEnv(envOverrides) {
  */
 export { captureProcessStartTime };
 /** Agent types the team runner supports. */
-const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 
@@ -294,30 +293,6 @@ export function resolveMode(requestedMode, defaultMode = 'plan') {
     }
     return normalizedDefault;
 }
-/** Ensure Gemini's settings.json has experimental.plan enabled for headless plan mode. */
-export async function ensureGeminiPlanMode() {
-    const settingsPath = path.join(os.homedir(), '.gemini', 'settings.json');
-    try {
-        let changed = false;
-        const settings = updateGeminiSettings(settingsPath, (nextSettings) => {
-            setGeminiAutoUpdateDisabled(nextSettings);
-            const experimental = typeof nextSettings.experimental === 'object' && nextSettings.experimental !== null
-                ? nextSettings.experimental
-                : {};
-            if (experimental.plan === true) {
-                return;
-            }
-            nextSettings.experimental = { ...experimental, plan: true };
-            changed = true;
-        });
-        if (changed && settings.experimental && typeof settings.experimental === 'object' && settings.experimental.plan === true) {
-            console.error('[Swarm] Enabled Gemini experimental.plan in', settingsPath);
-        }
-    }
-    catch (err) {
-        console.warn('[Swarm] Could not enable Gemini plan mode:', err);
-    }
-}
 /**
  * Check whether the CLI binary for a given agent type is installed.
  * Returns [available, pathOrError].
@@ -1312,6 +1287,14 @@ export class AgentManager {
     async spawn(taskName, agentType, prompt, cwd = null, mode = null, effort = 'medium', parentSessionId = null, workspaceDir = null, version = null, name = null, after = [], model = null, envOverrides = null, taskType = null, cloudProvider = null, cloudSessionId = null, cloudRepo = null, cloudBranch = null, worktreeName = null, worktreePath = null, profileName = null, hostName = null, hostTarget = null, repoPath = null) {
         await this.initialize();
         const resolvedMode = resolveMode(mode, this.defaultMode);
+        // Lineage (RUSH-2019): when the caller didn't name a parent, inherit the
+        // orchestrator's own session id from its env (exec.ts stamps AGENTS_SESSION_ID
+        // onto every agent process). A team spawned from inside a running agent then
+        // records which session created it, so the spawn chain traces back to a parent
+        // session; a team started outside any agent simply carries none.
+        if (!parentSessionId) {
+            parentSessionId = process.env.AGENTS_SESSION_ID ?? null;
+        }
         // Enforce: teammate names are unique within a team.
         const siblings = await this.listByTask(taskName);
         if (name && siblings.some((a) => a.name === name)) {

package/dist/lib/teams/index.d.ts

@@ -5,7 +5,7 @@
  * to reuse the same agent lifecycle, parsing, summarization, and persistence
  * layer that powers the `agents teams` CLI.
  */
-export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, type TaskType, type CloudDispatchFn, } from './agents.js';
+export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, getAgentsDir, resolveMode, type TaskType, type CloudDispatchFn, } from './agents.js';
 export { type AgentType } from './parsers.js';
 export { normalizeEvents, normalizeEvent, parseEvent } from './parsers.js';
 export { handleSpawn, handleStatus, handleStop, handleTasks, type SpawnResult, type AgentStatusDetail, type TaskStatusResult, type StopResult, type TaskInfo, type TasksResult, } from './api.js';

package/dist/lib/teams/index.js

@@ -5,7 +5,7 @@
  * to reuse the same agent lifecycle, parsing, summarization, and persistence
  * layer that powers the `agents teams` CLI.
  */
-export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, } from './agents.js';
+export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, getAgentsDir, resolveMode, } from './agents.js';
 export { normalizeEvents, normalizeEvent, parseEvent } from './parsers.js';
 export { handleSpawn, handleStatus, handleStop, handleTasks, } from './api.js';
 export { resolveAgentsDir, resolveBaseDir, } from './persistence.js';

package/dist/lib/types.d.ts

@@ -6,8 +6,8 @@
  * formats for each supported agent.
  */
 import type { CloudProviderId } from './cloud/types.js';
-/** Unique identifier for a supported AI coding agent. */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
+/** Unique identifier for a current or legacy AI coding agent. */
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
 /** Per-agent run strategy config. */
@@ -107,11 +107,11 @@ export interface AgentConfig {
      */
     cloudProvider?: CloudProviderId;
     /**
-     * Set when the upstream vendor has retired this agent's CLI. Presence marks
-     * the agent deprecated (it is never blocked from use); `warnAgentDeprecated`
-     * surfaces this in yellow whenever a user installs the agent or adds it to a
-     * team. Point `replacement` at the successor agent so the warning can suggest
-     * a migration path.
+     * Set when the upstream vendor has retired this agent's CLI. A warning-only
+     * deprecation leaves the agent manageable; a hard deprecation keeps the id
+     * parseable for legacy state but excludes it from install/import/sync targets.
+     * Point `replacement` at the successor agent so messages can suggest a
+     * migration path.
      */
     deprecated?: {
         /** Vendor that retired it, e.g. "Google". */
@@ -124,6 +124,8 @@ export interface AgentConfig {
         replacement?: AgentId;
         /** Announcement URL for the deprecation. */
         url?: string;
+        /** Hard-deprecated agents are retained only for legacy reads. */
+        hard?: boolean;
     };
     capabilities: {
         hooks: Capability;
@@ -745,7 +747,13 @@ export interface Meta {
      * passing `--durable` per unlock; off means the secure split default (survive
      * upgrade/restart, re-lock on sleep). */
     secrets?: {
-        policy?: 'always' | 'daily';
+        /** Default storage backend used when `agents secrets create/import` create a
+         * new bundle without `--backend` or `--synced`. */
+        backend?: 'keychain' | 'file' | 'vault';
+        /** Default prompt policy. `hold` (the default) holds a bundle for
+         * `agent.holdMs`; `daily`/`session` are accepted aliases kept so an existing
+         * agents.yaml keeps working. See SecretsPolicy in lib/secrets/bundles.ts. */
+        policy?: 'always' | 'hold' | 'daily';
         agent?: {
             auto?: boolean;
             holdMs?: number;
@@ -933,7 +941,7 @@ export interface BrowserProfileConfig {
     /** Optional SSH host where logDir lives, e.g. "user@remote-host". */
     logHost?: string;
 }
-/** Options controlling which agents and resources are synced during `agents repo refresh` / `agents use`. */
+/** Options controlling which agents and resources are synced during `agents sync` / `agents use`. */
 export interface SyncOptions {
     agents?: AgentId[];
     yes?: boolean;

package/dist/lib/usage.d.ts

@@ -79,11 +79,11 @@ export declare function buildCanonicalUsageContext(inputs: UsageIdentityInput[])
     usageFetchInputs: Map<string, UsageFetchInput>;
 };
 /**
- * Whether an agent exposes usage/limit data we can render — Claude/Kimi/Droid via
- * a live API, Codex via local session logs. Everything else has no usage concept,
- * so callers use this to decide whether a missing snapshot is worth flagging as
- * "usage unavailable" (a signed-in Claude account with no data) versus simply not
- * applicable (Antigravity, Grok, OpenCode).
+ * Whether an agent exposes usage/limit data we can render — Claude/Kimi/Droid/Cursor
+ * via a live API, Codex/Grok via local session logs. Everything else has no usage
+ * concept, so callers use this to decide whether a missing snapshot is worth
+ * flagging as "usage unavailable" (a signed-in Claude account with no data)
+ * versus simply not applicable (Antigravity, OpenCode).
  */
 export declare function agentReportsUsage(agentId: AgentId): boolean;
 /** Fetch usage info for all unique accounts in parallel, keyed by usage key. */
@@ -296,4 +296,27 @@ export declare function writeClaudeUsageCache(usageKey: string, snapshot: UsageS
  * Returns true only when a valid access token can be obtained.
  */
 export declare function isClaudeAuthValid(home?: string): Promise<boolean>;
+/** Per-model bucket in Cursor's /api/usage response. */
+interface CursorUsageModel {
+    numRequests?: number | null;
+    maxRequestUsage?: number | null;
+}
+/** Response shape from Cursor's dashboard usage endpoint. */
+export interface CursorUsageResponse {
+    /** The premium ("fast request") bucket the plan meters. */
+    'gpt-4'?: CursorUsageModel | null;
+    /** ISO timestamp the monthly request window resets from. */
+    startOfMonth?: string | null;
+    [model: string]: CursorUsageModel | string | null | undefined;
+}
+/**
+ * Normalize Cursor's /api/usage payload into the common UsageWindow shape.
+ *
+ * Only free / legacy request-capped plans carry a `maxRequestUsage` on the
+ * premium ("gpt-4") bucket — that's the fast-request cap the plan meters, and it
+ * maps cleanly to a monthly window. Usage-based plans report `maxRequestUsage:
+ * null` (no request cap — spend is metered in dollars instead), so they have no
+ * bar to draw here and return no windows rather than a misleading empty gauge.
+ */
+export declare function normalizeCursorUsage(data: CursorUsageResponse): UsageWindow[];
 export {};