@phnx-labs/agents-cli 1.20.78 → 1.20.82

package/dist/lib/session/db.js

@@ -2,7 +2,7 @@
  * SQLite-backed session index and full-text search.
  *
  * Stores session metadata and user-prompt text in a WAL-mode SQLite database
- * at ~/.agents/sessions/sessions.db. Provides incremental upsert, scan-stamp
+ * at ~/.agents/.history/sessions/sessions.db. Provides incremental upsert, scan-stamp
  * ledger (mtime/size tracking to skip unchanged files), FTS5 search with
  * BM25 ranking, and label-first search for /rename'd sessions.
  */
@@ -13,10 +13,11 @@ import { parseSession } from './parse.js';
 import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { getSessionsDir, getSessionsDbPath } from '../state.js';
 import { machineForSessionFile } from './origin-machine.js';
+import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 18;
+const SCHEMA_VERSION = 20;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -63,6 +64,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   output_tokens INTEGER,
   cost_usd REAL,
   duration_ms INTEGER,
+  model TEXT,
   file_path TEXT NOT NULL,
   file_mtime_ms INTEGER,
   file_size INTEGER,
@@ -77,7 +79,9 @@ CREATE TABLE IF NOT EXISTS sessions (
   todos TEXT,
   recent_directories_touched TEXT,
   linear_project TEXT,
-  linear_project_url TEXT
+  linear_project_url TEXT,
+  actor TEXT,
+  initiated_by TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -360,6 +364,25 @@ function migrateSchema(db, fromVersion) {
         });
         txn(rows);
     }
+    if (fromVersion < 19) {
+        // v18 → v19: actor provenance (RUSH-2018) — who initiated the session and
+        // the actor's kind. Populated at write time from the resolved actor (the
+        // pid-registry/spawn path), not derivable from the transcript, so there is
+        // no ledger wipe here: a rescan can't backfill these, and forcing a full
+        // re-parse would be pure churn. Existing rows stay NULL until re-created.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'actor'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN actor TEXT`);
+        if (!cols.some(c => c.name === 'initiated_by'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN initiated_by TEXT`);
+    }
+    if (fromVersion < 20) {
+        // v19 → v20: persist the transcript's model for the static session list.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'model'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN model TEXT`);
+        db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -719,18 +742,20 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, origin, routine_name, routine_run_id,
     version, account, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
-    output_tokens, cost_usd, duration_ms,
+    output_tokens, cost_usd, duration_ms, model,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id, plan, todos,
-    recent_directories_touched, linear_project, linear_project_url, machine
+    recent_directories_touched, linear_project, linear_project_url, machine,
+    actor, initiated_by
   ) VALUES (
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
     @version, @account, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
-    @output_tokens, @cost_usd, @duration_ms,
+    @output_tokens, @cost_usd, @duration_ms, @model,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan, @todos,
-    @recent_directories_touched, @linear_project, @linear_project_url, @machine
+    @recent_directories_touched, @linear_project, @linear_project_url, @machine,
+    @actor, @initiated_by
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -760,6 +785,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     output_tokens = excluded.output_tokens,
     cost_usd = excluded.cost_usd,
     duration_ms = excluded.duration_ms,
+    model = excluded.model,
     file_path = excluded.file_path,
     file_mtime_ms = excluded.file_mtime_ms,
     file_size = excluded.file_size,
@@ -780,7 +806,15 @@ const upsertSessionStmt = (db) => db.prepare(`
       WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project_url
       ELSE COALESCE(excluded.linear_project_url, sessions.linear_project_url)
     END,
-    machine = excluded.machine
+    machine = excluded.machine,
+    -- actor / initiated_by record who launched the session. COALESCE(existing,
+    -- incoming) keeps a stored owner (a rescan carries no actor -> excluded.actor
+    -- is NULL -> the stored value wins, never clobbered) BUT backfills a row that
+    -- was inserted NULL-first — e.g. an older scanner, or any scan that ran before
+    -- the actor sidecar landed — once the sidecar-join finally provides one. Plain
+    -- exclusion locked those rows to NULL forever (RUSH-2018/2019 fix).
+    actor = COALESCE(sessions.actor, excluded.actor),
+    initiated_by = COALESCE(sessions.initiated_by, excluded.initiated_by)
 `);
 function enrichCachedSessionMeta(meta) {
     if (!meta.filePath)
@@ -838,6 +872,12 @@ function resolveMachine(meta) {
  */
 export function upsertSession(meta, content, scan) {
     meta = enrichCachedSessionMeta(meta);
+    // Join the durable sessionId -> actor sidecar (RUSH-2019) when the caller
+    // didn't already carry an actor, so a scanned transcript still attributes to a
+    // person. The ON CONFLICT COALESCEs actor/initiated_by, so this fills a fresh
+    // row AND backfills one indexed null-first (before its sidecar existed), while a
+    // rescan carrying no actor still keeps the stored owner.
+    const actorRec = meta.actor ? undefined : readSessionActorRecord(meta.id);
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const row = {
@@ -861,6 +901,7 @@ export function upsertSession(meta, content, scan) {
         output_tokens: meta.outputTokens ?? null,
         cost_usd: meta.costUsd ?? null,
         duration_ms: meta.durationMs ?? null,
+        model: meta.model ?? null,
         file_path: meta.filePath,
         file_mtime_ms: scan?.fileMtimeMs ?? null,
         file_size: scan?.fileSize ?? null,
@@ -876,6 +917,8 @@ export function upsertSession(meta, content, scan) {
         linear_project: meta.linearProject ?? null,
         linear_project_url: meta.linearProjectUrl ?? null,
         machine: resolveMachine(meta),
+        actor: meta.actor ?? actorRec?.actor ?? null,
+        initiated_by: meta.initiatedBy ?? actorRec?.initiatedBy ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -894,6 +937,12 @@ export function upsertSessionsBatch(entries) {
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const now = Date.now();
+    // One directory read for the whole batch: join the durable sessionId -> actor
+    // sidecar (RUSH-2019) so scanned transcripts attribute to a person. Only used
+    // for entries whose meta carries no actor; the ON CONFLICT COALESCEs the column,
+    // so this fills fresh rows AND backfills null-first ones, never clobbering a
+    // stored owner on rescan.
+    const actorIndex = loadSessionActorIndex();
     // Persist the Claude resumable-parse continuation (parser_state + content_text)
     // alongside the stamp. On a full/incremental Claude parse the caller passes the
     // serialized newState + accumulated user doc so the NEXT scan can resume from
@@ -972,6 +1021,7 @@ export function upsertSessionsBatch(entries) {
                     output_tokens: meta.outputTokens ?? null,
                     cost_usd: meta.costUsd ?? null,
                     duration_ms: meta.durationMs ?? null,
+                    model: meta.model ?? null,
                     file_path: meta.filePath,
                     file_mtime_ms: scan?.fileMtimeMs ?? null,
                     file_size: scan?.fileSize ?? null,
@@ -987,6 +1037,8 @@ export function upsertSessionsBatch(entries) {
                     linear_project: meta.linearProject ?? null,
                     linear_project_url: meta.linearProjectUrl ?? null,
                     machine: resolveMachine(meta),
+                    actor: meta.actor ?? actorIndex.get(meta.id)?.actor ?? null,
+                    initiated_by: meta.initiatedBy ?? actorIndex.get(meta.id)?.initiatedBy ?? null,
                 });
                 delText.run(meta.id);
                 insText.run(meta.id, 
@@ -1157,6 +1209,7 @@ function rowToMeta(row) {
         outputTokens: row.output_tokens ?? undefined,
         costUsd: row.cost_usd ?? undefined,
         durationMs: row.duration_ms ?? undefined,
+        model: row.model ?? undefined,
         version: row.version ?? undefined,
         account: row.account ?? undefined,
         topic: row.topic ?? undefined,
@@ -1172,6 +1225,10 @@ function rowToMeta(row) {
         linearProject: row.linear_project ?? undefined,
         linearProjectUrl: row.linear_project_url ?? undefined,
         machine: row.machine ?? undefined,
+        actor: row.actor ?? undefined,
+        // Narrow the free-text column to the known kinds; an unexpected value maps
+        // to undefined rather than being asserted as a valid kind.
+        initiatedBy: row.initiated_by === 'human' || row.initiated_by === 'agent' ? row.initiated_by : undefined,
     };
 }
 function parseJsonColumn(value) {

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

@@ -54,6 +54,7 @@ interface ClaudeSessionScan {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     messageCount: number;
     tokenCount?: number;
@@ -93,6 +94,7 @@ interface CodexSessionScan {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     messageCount: number;
     tokenCount?: number;
@@ -366,6 +368,7 @@ export interface ClaudeParseState {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     topic?: string;
     customTitle?: string;
     aiTitle?: string;
@@ -424,6 +427,7 @@ export interface ClaudeParserState {
     cwd?: string;
     gitBranch?: string;
     version?: string;
+    model?: string;
     entrypoint?: string;
     firstTsMs?: number;
     topic?: string;

package/dist/lib/session/discover.js

@@ -1000,6 +1000,7 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             filePath,
             gitBranch: scan.gitBranch,
             version: scan.version,
+            model: scan.model,
             account,
             topic: scan.topic,
             label,
@@ -1030,6 +1031,7 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             lastActivity: scan.lastActivity,
             filePath,
             account,
+            model: scan.model,
             label,
             messageCount: scan.messageCount,
             tokenCount: scan.tokenCount,
@@ -1327,6 +1329,7 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         filePath,
         gitBranch: scan.gitBranch,
         version: resolveSessionVersion('codex', filePath, scan.version, currentVersion),
+        model: scan.model,
         topic: scan.topic,
         messageCount: scan.messageCount,
         tokenCount: scan.tokenCount,
@@ -1545,6 +1548,7 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
         cwd,
         filePath,
         version: resolveSessionVersion('gemini', filePath, embeddedVersion, currentVersion),
+        model: sessionModel,
         topic,
         messageCount,
         tokenCount: sawTokenCount ? tokenCount : undefined,
@@ -2162,6 +2166,7 @@ function readHermesMeta(filePath) {
         project: platform,
         filePath,
         version: model,
+        model,
         topic,
         messageCount: messageCount || (typeof session.message_count === 'number' ? session.message_count : undefined),
     };
@@ -2260,6 +2265,7 @@ async function readDroidMeta(filePath, currentVersion) {
         cwd,
         filePath,
         version: resolveSessionVersion('droid', filePath, undefined, currentVersion),
+        model,
         topic: scan.topic,
         messageCount: scan.messageCount,
         tokenCount,
@@ -2403,6 +2409,7 @@ export function initClaudeParseState() {
         cwd: undefined,
         gitBranch: undefined,
         version: undefined,
+        model: undefined,
         topic: undefined,
         customTitle: undefined,
         aiTitle: undefined,
@@ -2587,6 +2594,8 @@ export function applyClaudeLine(state, parsed) {
     // Per-assistant-message cost: each event carries its own model, so we
     // multiply that event's raw token directions by that model's price.
     const model = parsed.message?.model;
+    if (typeof model === 'string' && model)
+        state.model = model;
     if (model && usageObj && typeof usageObj === 'object') {
         const eventCost = costOfUsage({
             model,
@@ -2619,6 +2628,7 @@ export function finalizeClaudeScan(state) {
         cwd: state.cwd,
         gitBranch: state.gitBranch,
         version: state.version,
+        model: state.model,
         topic: resolvedTopic,
         entrypoint: state.entrypoint,
         messageCount: state.messageCount,
@@ -2684,6 +2694,7 @@ export function serializeClaudeParserState(state, offset) {
         cwd: state.cwd,
         gitBranch: state.gitBranch,
         version: state.version,
+        model: state.model,
         entrypoint: state.entrypoint,
         firstTsMs: state.firstTsMs,
         topic: state.topic,
@@ -2744,6 +2755,7 @@ export function hydrateClaudeParseState(prior) {
         cwd: prior.cwd,
         gitBranch: prior.gitBranch,
         version: prior.version,
+        model: prior.model,
         topic: prior.topic,
         customTitle: prior.customTitle,
         aiTitle: prior.aiTitle,
@@ -3098,6 +3110,7 @@ export function finalizeCodexScan(state) {
         cwd: state.cwd,
         gitBranch: state.gitBranch,
         version: state.version,
+        model: state.model,
         topic: state.topic,
         messageCount: state.messageCount,
         tokenCount: state.tokenCount,

package/dist/lib/session/hook-sessions.d.ts

@@ -14,6 +14,15 @@ export interface HookSessionIndex {
     byTerminalId: Map<string, HookSessionRecord>;
     byPid: Map<number, HookSessionRecord>;
 }
+/**
+ * Read the deployed hook's record for one specific pid, or undefined if absent /
+ * corrupt / not fresh. `startedAtMs` (the live process's known start, when the
+ * caller has it) rejects a stale record left by a PRIOR process at a reused pid:
+ * the hook writes its record AFTER the agent boots, so a record whose `ts`
+ * predates the current process's start belongs to a dead predecessor. `ts` is
+ * Unix SECONDS (the hook stamps `date +%s`); `startedAtMs` is millis.
+ */
+export declare function readStateSessionRecord(pid: number, startedAtMs?: number): HookSessionRecord | undefined;
 /**
  * Scan the hook state dir once and index every record by launch_id, terminal_id,
  * and pid. Returns empty maps if the dir is absent. Newest-by-`ts` wins a key

package/dist/lib/session/hook-sessions.js

@@ -1,13 +1,18 @@
 /**
  * Read-only view of the SessionStart hook's live-session state files.
  *
- * The `@agents/session-tracker` hook (installed into each agent's own config)
- * writes `~/.agents/.cache/terminals/sessions/<pid>.json` AFTER an agent boots,
- * carrying the agent's OWN authoritative session id (from its SessionStart
- * payload) plus the join keys `launch_id` / `terminal_id`. It is the only writer
- * that sees agents `ag run` did NOT launch (you typing `claude` in a terminal),
- * and the only source of an exact id for non-Claude agents (whose id we can't
- * know at spawn).
+ * Two on-disk sources carry a non-Claude agent's authoritative id (whose id we
+ * can't know at spawn), both read here:
+ *   1. The `@agents/session-tracker` hook writes
+ *      `~/.agents/.cache/terminals/sessions/<pid>.json` with the id plus the join
+ *      keys `launch_id` / `terminal_id`. Rich schema, but this package is NOT
+ *      deployed on the fleet — its dir is empty there. Scanned into the index by
+ *      {@link loadHookSessionIndex}.
+ *   2. The ACTUALLY-DEPLOYED SessionStart hook writes
+ *      `~/.agents/.cache/state/sessions/<pid>.json` ({@link readStateSessionRecord})
+ *      — `{session_id,cwd,pid,ts}`, keyed purely by pid. This is the real fleet id
+ *      source for every agent; read targeted per-pid, never scanned (RUSH-2007).
+ * Both see agents `ag run` did NOT launch (you typing `claude` in a terminal).
  *
  * This module lets `sessions --active` reconcile a `ps`-discovered pid to that
  * authoritative id. It is deliberately a small hand-rolled reader — the CLI does
@@ -23,12 +28,56 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { getTerminalsDir } from '../state.js';
+import { getTerminalsDir, getRuntimeStateDir } from '../state.js';
 function hookSessionsDir() {
     // Sibling of the pid-registry's by-pid/ dir. The hook hardcodes this same path
     // (packages/session-tracker/src/hook.sh); we read it, never move it.
     return path.join(getTerminalsDir(), 'sessions');
 }
+/**
+ * The path the ACTUALLY-DEPLOYED SessionStart hook writes:
+ * `~/.agents/.cache/state/sessions/<pid>.json`, carrying `{session_id,cwd,pid,ts}`
+ * for EVERY agent (claude/codex/gemini/kimi/grok/antigravity). This is the fleet's
+ * real id source; the `terminals/sessions/` path above belongs to the separate
+ * `@agents/session-tracker` package, which is not deployed (its dir is empty on the
+ * fleet), so a non-Claude tmux session's id resolved ONLY through the index above
+ * never landed (RUSH-2007). These records are keyed purely by pid — no
+ * launch_id/terminal_id/agent — so they join only on pid. The dir is an unpruned
+ * graveyard (thousands of dead-pid files), so this is a TARGETED per-pid read on
+ * demand, never a full-dir scan folded into {@link loadHookSessionIndex}.
+ */
+function stateSessionRecordPath(pid) {
+    return path.join(getRuntimeStateDir(), 'sessions', `${pid}.json`);
+}
+/**
+ * Read the deployed hook's record for one specific pid, or undefined if absent /
+ * corrupt / not fresh. `startedAtMs` (the live process's known start, when the
+ * caller has it) rejects a stale record left by a PRIOR process at a reused pid:
+ * the hook writes its record AFTER the agent boots, so a record whose `ts`
+ * predates the current process's start belongs to a dead predecessor. `ts` is
+ * Unix SECONDS (the hook stamps `date +%s`); `startedAtMs` is millis.
+ */
+export function readStateSessionRecord(pid, startedAtMs) {
+    if (!pid || pid < 1)
+        return undefined;
+    let rec;
+    try {
+        rec = parseRecord(fs.readFileSync(stateSessionRecordPath(pid), 'utf8'));
+    }
+    catch {
+        return undefined; // absent (the common case) or unreadable
+    }
+    if (!rec)
+        return undefined;
+    if (startedAtMs !== undefined && typeof rec.ts === 'number') {
+        // Allow a small skew: the hook fires just after exec, and ts is second-
+        // granular so it can floor to just before a sub-second process start.
+        const SKEW_MS = 5_000;
+        if (rec.ts * 1000 < startedAtMs - SKEW_MS)
+            return undefined; // reused-pid graveyard record
+    }
+    return rec;
+}
 function parseRecord(raw) {
     try {
         const o = JSON.parse(raw);

package/dist/lib/session/pid-registry.d.ts

@@ -4,6 +4,19 @@ export interface PidSessionEntry {
     /** The launch session id. Present for agents launched with a known id (Claude). */
     sessionId?: string;
     cwd?: string;
+    /**
+     * Resolved actor id (`resolveActor().id`) stamped at spawn — who initiated this
+     * run. A tailnet login/email for a resolved human, or `UNRESOLVED@<host>` when
+     * it can't be determined. Read back by the active-sessions path to surface an
+     * `owner` per session (RUSH-2018), so a co-located fleet shows who launched what.
+     */
+    actor?: string;
+    /**
+     * The actor's kind (`resolveActor().kind`): `'human'` for a person-initiated
+     * run, `'agent'` for one an agent spawned. Pairs with {@link actor} the same way
+     * `AGENTS_ACTOR` / `AGENTS_ACTOR_KIND` do on the exec env.
+     */
+    initiatedBy?: 'human' | 'agent';
     /**
      * The launch id minted by `ag run` and exported to the child as
      * `AGENT_LAUNCH_ID`. The agent's SessionStart hook records the SAME id in its

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

@@ -64,6 +64,8 @@ export interface SessionStats {
 }
 /** Compute aggregate statistics (turns, tools, tokens, duration) from session events. */
 export declare function computeSummaryStats(events: SessionEvent[]): SessionStats;
+/** Strip the 'claude-' prefix and date suffix from a model identifier. */
+export declare function shortenModel(model: string): string;
 /** Format a duration in milliseconds as a human-readable string (e.g. '12 min', '2h 30min'). */
 export declare function formatDuration(ms: number): string;
 /**

package/dist/lib/session/render.js

@@ -220,7 +220,7 @@ export function computeSummaryStats(events) {
     };
 }
 /** Strip the 'claude-' prefix and date suffix from a model identifier. */
-function shortenModel(model) {
+export function shortenModel(model) {
     return model.replace(/^claude-/, '').replace(/-\d{8}$/, '');
 }
 /** Format a token count as a human-readable string (e.g. 67.5K, 1.2M). */

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

@@ -119,6 +119,8 @@ export interface SessionMeta {
     costUsd?: number;
     /** Wall-clock duration in ms (lastTs − firstTs), persisted at scan time. */
     durationMs?: number;
+    /** Underlying LLM model observed in the transcript, when the agent records one. */
+    model?: string;
     version?: string;
     account?: string;
     topic?: string;
@@ -190,6 +192,20 @@ export interface SessionMeta {
      * undefined for sessions obtained outside that path.
      */
     machine?: string;
+    /**
+     * Resolved actor id (`resolveActor().id`) who initiated this session — a
+     * tailnet login/email for a resolved human, or `UNRESOLVED@<host>`. Persisted
+     * write-once at session creation and preserved across content rescans (kept
+     * out of the DB upsert's ON CONFLICT set). Undefined for rows created before
+     * actor stamping. RUSH-2018.
+     */
+    actor?: string;
+    /**
+     * The actor's kind (`resolveActor().kind`): `'human'` for a person-initiated
+     * run, `'agent'` for one an agent spawned. Pairs with {@link actor}, same
+     * split as `AGENTS_ACTOR` / `AGENTS_ACTOR_KIND` on the exec env. RUSH-2018.
+     */
+    initiatedBy?: 'human' | 'agent';
     /**
      * True only for rows pulled from another machine over the live cross-machine
      * fan-out (`remote-list.ts`) — their transcript is on that peer's disk, so

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;