@phnx-labs/agents-cli 1.20.78 → 1.20.83

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/state.js

@@ -619,6 +619,62 @@ function writeIfChanged(filePath, content) {
  * All callers funnel through writeMeta → here, so nothing else changes. Empty
  * `agents:` / `versions:` are not written (no empty committed files).
  */
+/**
+ * Serialize the central (synced) meta to `agents.yaml` WITHOUT destroying the
+ * hand-written comments in the committed file.
+ *
+ * `yaml.stringify(central)` drops every comment, so the freshly-written bytes
+ * never equal the comment-annotated file on disk — `writeIfChanged`'s byte
+ * compare then rewrites on EVERY meta write, leaving `agents.yaml` perpetually
+ * dirty and wedging `agents sync` ("Blocked by local changes"). Instead we parse
+ * the existing file into a `yaml.Document` (which preserves comments + ordering)
+ * and edit only the keys that actually changed — untouched keys, and all their
+ * comments, are left byte-stable. If nothing central changed we return the exact
+ * existing bytes, so a device-field-only write no longer touches `agents.yaml` at
+ * all. Falls back to plain stringify only when the file doesn't exist yet.
+ */
+function serializeCentral(central) {
+    const isEmpty = Object.keys(central).length === 0;
+    let existing = null;
+    try {
+        existing = fs.readFileSync(META_FILE, 'utf-8');
+    }
+    catch {
+        /* first write — no file yet */
+    }
+    if (existing == null) {
+        // Empty central → header only. `yaml.stringify({})` emits `{}` (a FLOW empty
+        // map); once that lands on disk, a later parseDocument sees a flow root and
+        // doc.set() below would inherit flow, flow-ifying the whole file. Writing just
+        // the header avoids seeding that poison.
+        return isEmpty ? META_HEADER : META_HEADER + yaml.stringify(central);
+    }
+    const doc = yaml.parseDocument(existing);
+    const current = doc.toJSON() ?? {};
+    let changed = false;
+    for (const [k, v] of Object.entries(central)) {
+        if (JSON.stringify(current[k]) !== JSON.stringify(v)) {
+            doc.set(k, v);
+            changed = true;
+        }
+    }
+    for (const k of Object.keys(current)) {
+        if (!(k in central)) {
+            doc.delete(k);
+            changed = true;
+        }
+    }
+    // No central field changed → keep the file byte-identical (comments intact), so
+    // writeIfChanged skips it and the churn loop never starts.
+    if (!changed)
+        return existing;
+    // Everything cleared → header only (never leave a flow `{}` behind).
+    // Otherwise force BLOCK style: an existing flow root (e.g. a legacy `{}`) would
+    // otherwise make the edited nodes render flow (`disabledCommands: [ teams ]`
+    // instead of a `- teams` block list). collectionStyle pins the whole doc block
+    // while parseDocument still preserves comments + key ordering.
+    return isEmpty ? META_HEADER : doc.toString({ collectionStyle: 'block' });
+}
 function writeMetaUnlocked(meta) {
     const { agents, isolatedAgents, versions, defaultBrowserProfile, ...central } = meta;
     // Write the machine-local files FIRST, then strip central — so a crash mid-write
@@ -656,7 +712,7 @@ function writeMetaUnlocked(meta) {
         fs.mkdirSync(path.dirname(vrPath), { recursive: true });
         writeIfChanged(vrPath, JSON.stringify(versions, null, 2) + '\n');
     }
-    writeIfChanged(META_FILE, META_HEADER + yaml.stringify(central));
+    writeIfChanged(META_FILE, serializeCentral(central));
     metaCache = null;
 }
 /**

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 {};