@phnx-labs/agents-cli 1.22.23 → 1.22.24

package/dist/lib/resource-inventory.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Resource inventory — the single chokepoint for "what does this agent@version
+ * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ *
+ * One API answers four orthogonal questions per (agent, version, kind):
+ *
+ *   capable   — the agent+version feature flags allow the kind at all
+ *   declared  — resources the DotAgents layers (project/user/system/extra)
+ *               declare for sync
+ *   onDisk    — resources actually installed in the version home filesystem
+ *               (the installed-resource truth — NOT agents.yaml tracking data)
+ *   wired     — resources the harness native config references so they fire
+ *   unmanaged — onDisk − declared (orphans no layer declares anymore)
+ *
+ * Callers (inspect, doctor, view, sync) MUST come here rather than
+ * re-implementing path joins or config parsing per command. Wiring parsing
+ * currently covers the settings.json family (claude, droid,
+ * muse), Grok hooks.json, and Kimi config.toml via checkVersionHookWiring.
+ */
+import type { AgentId } from './types.js';
+import { type HookWiringReport } from './hooks.js';
+/** Resource kinds the inventory can report. Only 'hooks' is implemented so far
+ *  (RUSH-2238); the remaining kinds land with their follow-up tickets. */
+export type InventoryKind = 'hooks' | 'skills' | 'commands' | 'plugins' | 'mcp';
+/** A reference to one resource in one state (declared / onDisk / wired). */
+export interface ResourceRef {
+    /** Stable install name (script basename without extension for hooks). */
+    name: string;
+    /** Declared/onDisk: absolute file path. Wired: the command string the native
+     *  config references. */
+    path: string;
+    /** Origin: a layer name for declared ('project' | 'user' | 'system' | extra
+     *  repo alias), 'user'/'project' scope or 'version-home' for onDisk,
+     *  'native-config' for wired. */
+    source: string;
+    /** Optional context — e.g. the lifecycle events a wired hook fires on. */
+    detail?: string;
+}
+export interface ResourceInventory {
+    agent: AgentId;
+    version: string;
+    kind: InventoryKind;
+    /** Agent+version feature flags allow this kind (version-aware gate). */
+    capable: boolean;
+    /** Declared in the DotAgents layers. */
+    declared: ResourceRef[];
+    /** Installed on disk in the version home. */
+    onDisk: ResourceRef[];
+    /** Referenced by the harness native config (empty when wiringSupported is
+     *  false — the format parser for that harness is not implemented yet). */
+    wired: ResourceRef[];
+    /** onDisk − declared: installed orphans no layer declares. */
+    unmanaged: ResourceRef[];
+    /** Whether this harness's native wiring was read successfully. When false,
+     *  `wired: []` means "unknown" (unsupported family OR unparseable config),
+     *  NOT "nothing wired". Format-supported but corrupt configs set this false. */
+    wiringSupported: boolean;
+    /** Native-format diagnostic retained for doctor; derived in this same pass. */
+    wiring?: HookWiringReport;
+}
+/**
+ * The single inventory API. Harness-scoped (claude/codex/grok/kimi/droid) —
+ * never a model or profile. Throws for kinds without an implementation rather
+ * than returning a half-empty report that looks like truth.
+ */
+export declare function getResourceInventory(agent: AgentId, version: string, kind: InventoryKind, opts?: {
+    cwd?: string;
+}): ResourceInventory;
+/**
+ * On-disk hook listing for an explicit home (version home or effective home)
+ * plus the project overlay — the one listing `getAgentResources` routes
+ * through, so inspect/doctor/view share a single hooks source. Paths resolve
+ * through the absolute-hooksDir-safe join (RUSH-2237), so grok/kimi version
+ * homes list their real hooks.
+ */
+export declare function listOnDiskHooks(agent: AgentId, opts?: {
+    home?: string;
+    cwd?: string;
+}): ResourceRef[];

package/dist/lib/resource-inventory.js

@@ -0,0 +1,122 @@
+/**
+ * Resource inventory — the single chokepoint for "what does this agent@version
+ * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ *
+ * One API answers four orthogonal questions per (agent, version, kind):
+ *
+ *   capable   — the agent+version feature flags allow the kind at all
+ *   declared  — resources the DotAgents layers (project/user/system/extra)
+ *               declare for sync
+ *   onDisk    — resources actually installed in the version home filesystem
+ *               (the installed-resource truth — NOT agents.yaml tracking data)
+ *   wired     — resources the harness native config references so they fire
+ *   unmanaged — onDisk − declared (orphans no layer declares anymore)
+ *
+ * Callers (inspect, doctor, view, sync) MUST come here rather than
+ * re-implementing path joins or config parsing per command. Wiring parsing
+ * currently covers the settings.json family (claude, droid,
+ * muse), Grok hooks.json, and Kimi config.toml via checkVersionHookWiring.
+ */
+import { AGENTS } from './agents.js';
+import { supports } from './capabilities.js';
+import { listResources } from './resources.js';
+import { checkVersionHookWiring, listHooksInVersionHome, listInstalledHooksWithScope, } from './hooks.js';
+const IMPLEMENTED_KINDS = ['hooks'];
+/**
+ * The single inventory API. Harness-scoped (claude/codex/grok/kimi/droid) —
+ * never a model or profile. Throws for kinds without an implementation rather
+ * than returning a half-empty report that looks like truth.
+ */
+export function getResourceInventory(agent, version, kind, opts = {}) {
+    if (!IMPLEMENTED_KINDS.includes(kind)) {
+        // Fail loud at the boundary: the kind is part of the API shape but its
+        // inventory lands with a RUSH-2236 follow-up — a silent empty report would
+        // read as "nothing installed".
+        throw new Error(`getResourceInventory: kind '${kind}' is not implemented yet (implemented: ${IMPLEMENTED_KINDS.join(', ')}; tracked under RUSH-2236)`);
+    }
+    return hooksInventory(agent, version, opts.cwd);
+}
+/**
+ * On-disk hook listing for an explicit home (version home or effective home)
+ * plus the project overlay — the one listing `getAgentResources` routes
+ * through, so inspect/doctor/view share a single hooks source. Paths resolve
+ * through the absolute-hooksDir-safe join (RUSH-2237), so grok/kimi version
+ * homes list their real hooks.
+ */
+export function listOnDiskHooks(agent, opts = {}) {
+    return listInstalledHooksWithScope(agent, opts.cwd ?? process.cwd(), { home: opts.home }).map((h) => ({
+        name: h.name,
+        path: h.path,
+        source: h.scope,
+        detail: h.dataFile,
+    }));
+}
+function hooksInventory(agent, version, cwd) {
+    const capable = supports(agent, 'hooks', version).ok;
+    // Declared: the layered DotAgents repos are the declaration surface. Hook
+    // script names carry their extension here ('git-guard.sh'); normalize to the
+    // extension-less install name so declared/onDisk sets compare.
+    const declared = listResources('hooks', cwd).map((r) => ({
+        name: r.name.replace(/\.[^./]+$/, ''),
+        path: r.path,
+        source: r.source,
+    }));
+    // onDisk / wired need the version home; both are empty for an agent whose
+    // hooks capability is gated off (unknown agents included — AGENTS lookup
+    // would otherwise throw).
+    let onDisk = [];
+    let wired = [];
+    let wiringSupported = false;
+    let wiring;
+    if (capable && AGENTS[agent]?.supportsHooks) {
+        onDisk = listHooksInVersionHome(agent, version).map((e) => ({
+            name: e.name,
+            path: e.scriptPath,
+            source: 'version-home',
+            detail: e.dataFile,
+        }));
+        const report = checkVersionHookWiring(agent, version);
+        wiring = report;
+        // supported=true means the harness format is known; settingsUnparseable means
+        // we could not trust the file. Only report wired counts when the parse succeeded —
+        // otherwise inspect/doctor would render "wired 0" for corrupt configs (PR #2140 review).
+        wiringSupported = report.supported && !report.settingsUnparseable;
+        if (wiringSupported) {
+            // One ref per hook, events folded into detail — a hook wired under
+            // PreToolUse AND Stop is one inventory entry, not two.
+            const eventsByName = new Map();
+            const commandByName = new Map();
+            for (const issue of report.wired) {
+                let events = eventsByName.get(issue.name);
+                if (!events) {
+                    events = new Set();
+                    eventsByName.set(issue.name, events);
+                    commandByName.set(issue.name, issue.command);
+                }
+                events.add(issue.event);
+            }
+            wired = [...eventsByName.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([name, events]) => ({
+                name,
+                path: commandByName.get(name),
+                source: 'native-config',
+                detail: [...events].sort().join('/'),
+            }));
+        }
+    }
+    const declaredNames = new Set(declared.map((r) => r.name));
+    const unmanaged = onDisk.filter((r) => !declaredNames.has(r.name));
+    return {
+        agent,
+        version,
+        kind: 'hooks',
+        capable,
+        declared,
+        onDisk,
+        wired,
+        unmanaged,
+        wiringSupported,
+        wiring,
+    };
+}

package/dist/lib/resources.js

@@ -7,7 +7,7 @@ import * as path from 'path';
 import { AGENTS, listInstalledMcpsWithScope } from './agents.js';
 import { listInstalledCommandsWithScope } from './commands.js';
 import { listInstalledSkillsWithScope } from './skills.js';
-import { listInstalledHooksWithScope } from './hooks.js';
+import { listOnDiskHooks } from './resource-inventory.js';
 import { listInstalledInstructionsWithScope } from './rules/rules.js';
 import { getEffectiveHome } from './versions.js';
 import { listMcpServerConfigs } from './mcp.js';
@@ -352,11 +352,14 @@ export function getAgentResources(agentId, options = {}) {
             });
         }
     }
-    // Hooks
+    // Hooks — routed through the resource-inventory chokepoint (RUSH-2238) so
+    // inspect/doctor/view share one listing and one (absolute-hooksDir-safe)
+    // path resolution.
     const hooks = [];
-    for (const hook of listInstalledHooksWithScope(agentId, cwd, { home })) {
-        if (shouldInclude(hook.scope)) {
-            hooks.push({ name: hook.name, path: hook.path, scope: hook.scope });
+    for (const ref of listOnDiskHooks(agentId, { cwd, home })) {
+        const hookScope = ref.source;
+        if (shouldInclude(hookScope)) {
+            hooks.push({ name: ref.name, path: ref.path, scope: hookScope });
         }
     }
     // Workflows

package/dist/lib/run-defaults.d.ts

@@ -21,6 +21,7 @@ export interface ResolvedRunDefaults extends RunDefaults {
     sources: {
         mode?: string;
         model?: string;
+        effort?: string;
     };
 }
 export interface RunDefaultEntry {
@@ -30,6 +31,7 @@ export interface RunDefaultEntry {
 type RunDefaultsInput = {
     mode?: unknown;
     model?: unknown;
+    effort?: unknown;
 };
 export declare function normalizeRunDefaultMode(input: string): Mode;
 export declare function parseRunDefaultSelector(input: string): ParsedRunDefaultSelector;

package/dist/lib/run-defaults.js

@@ -17,6 +17,7 @@ import { readMeta, updateMeta } from './state.js';
 import { getProjectRunConfigs } from './run-config.js';
 import chalk from 'chalk';
 const VERSION_RE = /^(?:\*|latest|(?!.*\.\.)[A-Za-z0-9._+-]{1,64})$/;
+const RUN_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
 function isAgentId(value) {
     return value in AGENTS;
 }
@@ -42,6 +43,12 @@ function normalizeRunDefaults(defaults, selector) {
         }
         out.model = defaults.model.trim();
     }
+    if (defaults.effort !== undefined) {
+        if (typeof defaults.effort !== 'string' || !RUN_EFFORTS.includes(defaults.effort)) {
+            throw new Error('Invalid effort in run.defaults.' + selector + ': use one of: ' + RUN_EFFORTS.join(', ') + '.');
+        }
+        out.effort = defaults.effort;
+    }
     return out;
 }
 export function parseRunDefaultSelector(input) {
@@ -97,6 +104,10 @@ export function resolveRunDefaultsFromConfig(runConfig, agent, version) {
         resolved.model = wildcard.model;
         resolved.sources.model = wildcardSelector;
     }
+    if (wildcard?.effort) {
+        resolved.effort = wildcard.effort;
+        resolved.sources.effort = wildcardSelector;
+    }
     if (exactSelector && defaults[exactSelector]) {
         const exact = normalizeRunDefaults(defaults[exactSelector], exactSelector);
         if (exact.mode) {
@@ -107,6 +118,10 @@ export function resolveRunDefaultsFromConfig(runConfig, agent, version) {
             resolved.model = exact.model;
             resolved.sources.model = exactSelector;
         }
+        if (exact.effort) {
+            resolved.effort = exact.effort;
+            resolved.sources.effort = exactSelector;
+        }
     }
     return resolved;
 }
@@ -122,6 +137,10 @@ export function resolveRunDefaultsFromConfigs(runConfigs, agent, version) {
             resolved.model = next.model;
             resolved.sources.model = next.sources.model;
         }
+        if (next.effort) {
+            resolved.effort = next.effort;
+            resolved.sources.effort = next.sources.effort;
+        }
     }
     return resolved;
 }
@@ -135,6 +154,8 @@ export function formatRunDefaultEntry(entry) {
         parts.push(`mode ${chalk.white(entry.defaults.mode)}`);
     if (entry.defaults.model)
         parts.push(`model ${chalk.white(entry.defaults.model)}`);
+    if (entry.defaults.effort)
+        parts.push('effort ' + chalk.white(entry.defaults.effort));
     return `${chalk.cyan(entry.selector.padEnd(22))} ${parts.join('  ')}`;
 }
 export function listRunDefaults() {
@@ -149,8 +170,8 @@ export function listRunDefaults() {
 export function setRunDefault(selectorInput, defaultsInput) {
     const parsed = parseRunDefaultSelector(selectorInput);
     const defaults = normalizeRunDefaults(defaultsInput, parsed.selector);
-    if (!defaults.mode && !defaults.model) {
-        throw new Error('Set at least one default: --mode <mode> or --model <model>.');
+    if (!defaults.mode && !defaults.model && !defaults.effort) {
+        throw new Error('Set at least one default: --mode <mode>, --model <model>, or --effort <effort>.');
     }
     updateMeta((meta) => {
         const run = { ...(meta.run ?? {}) };

package/dist/lib/runner.js

@@ -31,7 +31,8 @@ import { backgroundSpawnOptions, killTree } from './platform/process.js';
 import lockfile from 'proper-lockfile';
 import { ensureLockTarget } from './fs-atomic.js';
 import { walkForFiles } from './fs-walk.js';
-import { getBinaryPath, isVersionInstalled, resolveVersion } from './versions.js';
+import { getBinaryPath, isVersionInstalled, resolveVersion, getVersionHomePath } from './versions.js';
+import { resolveClaudeSetupToken } from './claude-account-token.js';
 import { getConfiguredRunStrategy, resolveRunVersion, resolveAccountVersion, rotationFailoverChain, readinessFromCandidate, formatNoHealthyAccountError, } from './rotate.js';
 import { readAuthHealth, isDeadVerdict } from './auth-health.js';
 import { machineId } from './machine-id.js';
@@ -537,22 +538,26 @@ export function buildRoutineSpawnEnv(baseEnv, agent, version, timezone, overlayH
         if (v !== undefined)
             out[k] = v;
     }
-    // A routine authenticates through the pinned account's own CLAUDE_CONFIG_DIR
-    // login on THIS box (buildExecEnv points it at the per-account version home).
-    // Claude Code's interactive session refreshes itself per-device; keeping the
-    // daemon out of the credential entirely is what avoids the fleet-wide rotation
-    // logout — a shared/rotating token was the cause, not the fix.
-    //
-    // Injecting a token was already ruled out, but INHERITING one was not:
-    // buildExecEnv spreads the ambient process.env (exec.ts) and sanitizeProcessEnv
-    // only strips loader/interpreter vars, never credentials. So on any box whose
-    // daemon environment happens to carry CLAUDE_CODE_OAUTH_TOKEN, every routine
-    // spawn silently ran on that one shared rotating token instead of the host's
-    // own login — the exact fleet-wide-logout path, arriving by inheritance rather
-    // than injection. CI never caught it because CI has no token to inherit; a
-    // provisioned box does. Drop it here so a routine always uses the login of the
-    // machine it runs on.
-    delete out.CLAUDE_CODE_OAUTH_TOKEN;
+    // CLAUDE_CODE_OAUTH_TOKEN comes in two flavours, and only one is safe for a
+    // routine. KEEP a per-account `claude setup-token` (long-lived, NON-rotating,
+    // keyed to this home's own account) that buildExecEnv injected from the reserved
+    // `auth` bundle (resolveClaudeSetupToken) — that is the durable cure for the
+    // single-use-refresh-token revocation storm: a setup-token never rotates, so a
+    // scheduled routine can't land on a sibling home's just-rotated-out credential.
+    // STRIP an INHERITED ambient value instead: buildExecEnv spreads process.env
+    // (exec.ts) and sanitizeProcessEnv leaves credentials, so a daemon env that
+    // happens to carry a shared/rotating CLAUDE_CODE_OAUTH_TOKEN would otherwise make
+    // every routine run on that one token — the RUSH-1822 fleet-wide-logout path.
+    // Distinguish by value: only the resolved setup-token survives.
+    // Authoritative: buildExecEnv injects the setup-token but then spreads the caller
+    // env over it, so an ambient CLAUDE_CODE_OAUTH_TOKEN would win — re-assert here.
+    const setupToken = agent === 'claude' && version
+        ? resolveClaudeSetupToken(getVersionHomePath('claude', version))
+        : null;
+    if (setupToken)
+        out.CLAUDE_CODE_OAUTH_TOKEN = setupToken;
+    else
+        delete out.CLAUDE_CODE_OAUTH_TOKEN;
     if (agent === 'cursor' && overlayHome) {
         // prepareJobHome links this host's Cursor auth file here. Pin XDG_CONFIG_HOME
         // to the overlay so an ambient value cannot bypass the routine sandbox.

package/dist/lib/secrets/Agents CLI.app/Contents/Info.plist

@@ -8,6 +8,8 @@
   <string>Agents CLI</string>
   <key>CFBundleDisplayName</key>
   <string>Agents CLI</string>
+  <key>CFBundleIconFile</key>
+  <string>AppIcon</string>
   <key>CFBundleExecutable</key>
   <string>Agents CLI</string>
   <key>CFBundlePackageType</key>

package/dist/lib/secrets/Agents CLI.app/Contents/_CodeSignature/CodeResources

@@ -3,9 +3,21 @@
 <plist version="1.0">
 <dict>
 	<key>files</key>
-	<dict/>
+	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<data>
+		DFq5H08EkhgWIC3UvGMR9B58BZw=
+		</data>
+	</dict>
 	<key>files2</key>
 	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			mBSjM6jlvN7J1jQowsvqTl7CHM0pur0e6qsHMuzk5k0=
+			</data>
+		</dict>
 		<key>embedded.provisionprofile</key>
 		<dict>
 			<key>hash2</key>