@phnx-labs/agents-cli 1.22.40 → 1.22.42

package/dist/lib/{runner.js → daemon/runner.js}

@@ -17,29 +17,29 @@ import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { getCliLaunch, getAgentsBinDir } from './cli-entry.js';
-import { resolveJobPrompt, parseTimeout, writeRunMeta, listRuns, getJobRunsDir, getRunDir, checkJobDeviceEligibility, finalizeRunMeta, resolveJobExecutionContext, slotRunId, claimRunSlot, readRunMeta, resolveHostStrategy, } from './scheduling/routines.js';
-import { getRunsDir, getUserAgentsDir, readMeta, getDaemonDir } from './state.js';
-import { shortCodexHome } from './codex-home.js';
-import { prepareJobHome, buildSpawnEnv, getJobHomePath } from './sandbox.js';
-import { resolveModel, buildReasoningFlags } from './models.js';
-import { createTimer, redactPrompt, emitRoutineEnd } from './feed/events.js';
-import { codexEditWritableRoots, codexPolicyArgs } from './codex-policy.js';
-import { applyAddDirs } from './add-dir.js';
-import { normalizeMode, resolveHeadlessMode, buildExecEnv, detectRateLimit, detectAuthFailure, isAuthFailureFromLog, authFailureReason, } from './exec.js';
-import { resolveActor } from './actor.js';
-import { loadTask as loadHostTask } from './hosts/tasks.js';
-import { reconcileTask as reconcileHostTask } from './hosts/reconcile.js';
-import { backgroundSpawnOptions, killTree } from './platform/process.js';
+import { getCliLaunch, getAgentsBinDir } from '../cli-entry.js';
+import { resolveJobPrompt, parseTimeout, writeRunMeta, listRuns, getJobRunsDir, getRunDir, checkJobDeviceEligibility, finalizeRunMeta, resolveJobExecutionContext, slotRunId, claimRunSlot, readRunMeta, resolveHostStrategy, } from '../scheduling/routines.js';
+import { getRunsDir, getUserAgentsDir, readMeta, getDaemonDir } from '../state.js';
+import { shortCodexHome } from '../codex-home.js';
+import { prepareJobHome, buildSpawnEnv, getJobHomePath } from '../sandbox.js';
+import { resolveModel, buildReasoningFlags } from '../models.js';
+import { createTimer, redactPrompt, emitRoutineEnd } from '../feed/events.js';
+import { resolveHarnessAdapter } from '../harness/index.js';
+import { applyAddDirs } from '../add-dir.js';
+import { normalizeMode, resolveHeadlessMode, buildExecEnv, detectRateLimit, detectAuthFailure, isAuthFailureFromLog, authFailureReason, AGENT_COMMANDS, } from '../exec.js';
+import { resolveActor } from '../actor.js';
+import { loadTask as loadHostTask } from '../hosts/tasks.js';
+import { reconcileTask as reconcileHostTask } from '../hosts/reconcile.js';
+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, getVersionHomePath } from './installations/versions.js';
-import { resolveClaudeSetupToken } from './claude-account-token.js';
-import { getConfiguredRunStrategy, resolveRunVersion, resolveAccountVersion, rotationFailoverChain, readinessFromCandidate, formatNoHealthyAccountError, } from './accounting/rotate.js';
-import { readAuthHealth, isDeadVerdict } from './auth-health.js';
-import { machineId } from './machine-id.js';
-import { isSelfUpdatingAgent, ROUTINE_AGENT_COMMANDS as AGENT_COMMANDS, isAgentHardDeprecated, hardDeprecationError } from './agents.js';
+import { ensureLockTarget } from '../fs-atomic.js';
+import { walkForFiles } from '../fs-walk.js';
+import { getBinaryPath, isVersionInstalled, resolveVersion, getVersionHomePath } from '../installations/versions.js';
+import { resolveClaudeSetupToken } from '../claude-account-token.js';
+import { getConfiguredRunStrategy, resolveRunVersion, resolveAccountVersion, rotationFailoverChain, readinessFromCandidate, formatNoHealthyAccountError, } from '../accounting/rotate.js';
+import { readAuthHealth, isDeadVerdict } from '../auth-health.js';
+import { machineId } from '../machine-id.js';
+import { isSelfUpdatingAgent, ROUTINE_AGENT_COMMANDS, isAgentHardDeprecated, hardDeprecationError } from '../agents.js';
 export class RoutineAlreadyRunningError extends Error {
     constructor(jobName, runId) {
         super(`Routine '${jobName}' already has a running execution (${runId})`);
@@ -416,6 +416,17 @@ async function runWithAttempt(config, trigger, run, wrapTerminal) {
 function terminateRoutineTree(pid) {
     if (!pid)
         return;
+    // Never take THIS process down. Both kills below are unconditional SIGKILLs,
+    // so a RunMeta naming the reaper's own pid -- a reused pid, a record written
+    // by the process now doing the reaping, or a hand-written fixture -- makes the
+    // reaper SIGKILL itself, and via `-pid` its whole process group with it. There
+    // is no recovery from that: the run is never finalized, and on the daemon it
+    // takes the scheduler down mid-sweep. daemon.ts:457 already refuses to evict an
+    // incumbent whose pid is `process.pid` for exactly this reason; the reap path
+    // needs the same guard. Skipping the kill still lets the caller finalize the
+    // run record, which is the part that matters.
+    if (pid === process.pid)
+        return;
     if (process.platform === 'win32') {
         killTree(pid);
         return;
@@ -503,94 +514,20 @@ export function buildJobCommand(config, resolvedPrompt, forwardAccount = true) {
             cmd.push('--account', config.account);
         return cmd;
     }
-    const template = AGENT_COMMANDS[agent];
+    const template = ROUTINE_AGENT_COMMANDS[agent];
     if (!template) {
         throw new Error(`Unsupported agent for daemon jobs: ${agent}`);
     }
     let cmd = template.map((part) => part.replace('{prompt}', resolvedPrompt));
     // Canonicalize mode (accepts legacy `full` as alias for `skip`).
     const mode = normalizeMode(config.mode);
-    if (config.agent === 'claude') {
-        if (mode === 'edit') {
-            const planIndex = cmd.indexOf('plan');
-            if (planIndex !== -1)
-                cmd[planIndex] = 'acceptEdits';
-        }
-        else if (mode === 'auto') {
-            const planIndex = cmd.indexOf('plan');
-            if (planIndex !== -1)
-                cmd[planIndex] = 'auto';
-        }
-        else if (mode === 'skip') {
-            // Replace --permission-mode plan with --dangerously-skip-permissions
-            const pmIndex = cmd.indexOf('--permission-mode');
-            if (pmIndex !== -1)
-                cmd.splice(pmIndex, 2, '--dangerously-skip-permissions');
-        }
-        appendModelAndReasoning(cmd, config);
-    }
-    if (config.agent === 'codex') {
-        const policyMode = mode === 'plan' || mode === 'skip' ? mode : 'edit';
-        const routineRoots = (config.allow?.dirs ?? []).map((dir) => {
-            if (dir.startsWith('-')) {
-                throw new Error(`allow.dirs entries must not start with '-': ${JSON.stringify(dir)}`);
-            }
-            return dir.replace(/^~/, os.homedir());
-        });
-        cmd.push(...codexPolicyArgs(policyMode, [...codexEditWritableRoots(), ...routineRoots]));
-        appendModelAndReasoning(cmd, config);
-    }
-    if (config.agent === 'cursor') {
-        if (mode === 'plan') {
-            cmd.push('--plan');
-        }
-        else if (mode === 'skip') {
-            cmd.push('-f');
-        }
-        else {
-            // The configured cwd is the user's workspace trust decision. --trust is
-            // narrower than --yolo/-f because it does not bypass tool permissions.
-            cmd.push('--trust');
-        }
-        appendModelAndReasoning(cmd, config);
-    }
-    if (config.agent === 'kimi') {
-        // kimi daemon jobs always run headless via `--prompt`, which cannot be
-        // combined with any startup-mode flag (--plan/--auto/--yolo all abort with
-        // "Cannot combine --prompt with --X"). edit/auto/skip reduce to kimi's default
-        // headless auto-run, so emit no flag. plan has no headless read-only
-        // equivalent, so resolveHeadlessMode downgrades a plan request to auto with a
-        // stderr warning (kimi's headlessPlan is false) — routines run headless, so
-        // interactive is always false here. The returned mode carries no flag either.
-        resolveHeadlessMode('kimi', mode, false);
-        appendModelAndReasoning(cmd, config);
-    }
-    if (config.agent === 'droid') {
-        // droid exec defaults to read-only (plan). Escalate autonomy per mode.
-        if (mode === 'edit') {
-            cmd.push('--auto', 'low');
-        }
-        else if (mode === 'auto') {
-            cmd.push('--auto', 'high');
-        }
-        else if (mode === 'skip') {
-            cmd.push('--skip-permissions-unsafe');
-        }
-        appendModelAndReasoning(cmd, config);
-    }
-    if (config.agent === 'muse') {
-        // muse exec: plan ≈ no non-shell writes; auto skips approval prompts but
-        // keeps the OS sandbox; skip is --yolo (no approval, no sandbox, trust).
-        if (mode === 'plan') {
-            cmd.push('--disable-write');
-        }
-        else if (mode === 'auto') {
-            cmd.push('--disable-approval');
-        }
-        else if (mode === 'skip') {
-            cmd.push('--yolo');
-        }
-        // edit: default on-request approval + sandbox
+    // Routine launch-arg quirks (the harness axis of Move 3): each per-agent arm
+    // moves to its harness adapter; runner appends model/reasoning flags after,
+    // exactly as every arm did. Agents with no routine quirk have no adapter
+    // override, so they skip both — the old behavior for an entry with no arm.
+    const routineAdapter = resolveHarnessAdapter(agent);
+    if (routineAdapter.routineModeArgs) {
+        routineAdapter.routineModeArgs(cmd, { mode, config, resolveHeadlessMode });
         appendModelAndReasoning(cmd, config);
     }
     // allow.dirs → harness-specific grants. Codex is handled in its branch above
@@ -610,7 +547,7 @@ export function buildJobCommand(config, resolvedPrompt, forwardAccount = true) {
     return cmd;
 }
 /**
- * Append --model and reasoning flags to a command being assembled.
+ * Append the agent's canonical model flag and reasoning flags to a command.
  *
  * Pass-through model resolution: validates against the installed (agent, version)
  * catalog when possible and writes a warning to stderr on miss, but never blocks.
@@ -621,15 +558,19 @@ function appendModelAndReasoning(cmd, config) {
     const agent = config.agent;
     const model = config.config?.model;
     if (model) {
+        const modelFlag = AGENT_COMMANDS[agent].modelFlag;
+        if (!modelFlag) {
+            throw new Error(`Agent ${agent} does not support routine model selection`);
+        }
         if (config.version) {
             const resolved = resolveModel(agent, config.version, model);
             if (resolved.warning) {
                 process.stderr.write(`[agents] ${resolved.warning}\n`);
             }
-            cmd.push('--model', resolved.forwarded);
+            cmd.push(modelFlag, resolved.forwarded);
         }
         else {
-            cmd.push('--model', model);
+            cmd.push(modelFlag, model);
         }
     }
     const reasoning = config.config?.reasoning;
@@ -870,7 +811,7 @@ export async function resolveRoutineLaunch(config, cwd = process.cwd(), deps = {
     // resolveRoutineLaunch is only called for agent jobs (workflow returns above;
     // command jobs branch out of execute*Job before reaching this).
     const agent = config.agent;
-    const { findAccount, findUnifiedAccount, resolveAccountSelection, resolveCredentialAccount } = await import('./account-registry.js');
+    const { findAccount, findUnifiedAccount, resolveAccountSelection, resolveCredentialAccount } = await import('../account-registry.js');
     const meta = (deps.readMeta ?? readMeta)();
     const explicitCredential = config.account
         ? (deps.findCredentialAccount?.(config.account) ?? (deps.resolveCredentialAccount !== undefined || findAccount(config.account) !== null))
@@ -1026,7 +967,7 @@ export async function assertRoutineAccountLocalForPlacement(config, mode, deps =
         return;
     let account = deps.account;
     if (account === undefined) {
-        const { findUnifiedAccount } = await import('./account-registry.js');
+        const { findUnifiedAccount } = await import('../account-registry.js');
         account = findUnifiedAccount(config.account, (deps.readMeta ?? readMeta)());
     }
     if (!account) {
@@ -1246,7 +1187,7 @@ async function executeJobPlaced(config, deps, attempt) {
     // do not apply. Sync callers (manual `routines run`, catchup) follow the
     // remote run to completion when possible.
     {
-        const { resolvePlacementTarget } = await import('./routines-placement.js');
+        const { resolvePlacementTarget } = await import('../routines-placement.js');
         const target = await resolvePlacementTarget(config);
         const placed = await dispatchPlacedJob(config, target, attempt);
         if (placed)
@@ -1286,7 +1227,7 @@ async function executeJobPlaced(config, deps, attempt) {
     // (command jobs branched out earlier, so config.agent is set on the non-workflow path.)
     const effectiveAgent = config.workflow ? 'claude' : config.agent;
     if (!dispatchesViaAgentsRun(config)) {
-        const { findUnifiedAccount, resolveAccountSelection, resolveCredentialAccount } = await import('./account-registry.js');
+        const { findUnifiedAccount, resolveAccountSelection, resolveCredentialAccount } = await import('../account-registry.js');
         const meta = readMeta();
         const selectedAccount = resolveAccountSelection(config.account, effectiveAgent, meta);
         if (selectedAccount) {
@@ -1359,7 +1300,7 @@ async function executeJobPlaced(config, deps, attempt) {
                     .map((d) => d.replace(/^~/, os.homedir())),
             } : {}),
         };
-        const { runLoop } = await import('./loop.js');
+        const { runLoop } = await import('../loop.js');
         const loopResult = await runLoop(execOptions, config.loop, {
             runId,
             runDir,
@@ -1515,8 +1456,8 @@ async function executeJobOnCloud(config, opts, attempt) {
     if (!config.agent) {
         throw new Error(`Routine '${config.name}' hostStrategy: cloud requires an agent`);
     }
-    const { resolveProvider } = await import('./cloud/registry.js');
-    const { insertTask } = await import('./cloud/store.js');
+    const { resolveProvider } = await import('../cloud/registry.js');
+    const { insertTask } = await import('../cloud/store.js');
     const provider = resolveProvider(undefined, config.agent);
     const timer = createTimer('agent.run', {
         agent: config.agent,
@@ -1589,9 +1530,9 @@ async function executeJobOnHost(config, opts, attempt) {
     if (config.command) {
         throw new Error(`Routine '${config.name}' uses 'command:', which can't execute on a host yet — remove 'host:' or 'command:'.`);
     }
-    const { resolveHostRunTarget, dispatchPromptToHost } = await import('./hosts/run-target.js');
+    const { resolveHostRunTarget, dispatchPromptToHost } = await import('../hosts/run-target.js');
     const host = await resolveHostRunTarget(config.host);
-    const { evaluateHostActivationReadiness } = await import('./routine-readiness.js');
+    const { evaluateHostActivationReadiness } = await import('../routine-readiness.js');
     const readiness = await evaluateHostActivationReadiness(config);
     if (!readiness.ready)
         throw new Error(`${readiness.readiness?.code ?? 'not_ready'}: ${readiness.readiness?.message ?? 'target is not ready'}`);
@@ -1739,7 +1680,7 @@ async function executeJobDetachedClaimed(config, attempt, hooks) {
     // (the monitor tick observes an already-finalized record), so notify-desktop
     // sends the finish notification only for local detached runs below (RUSH-2030).
     {
-        const { resolvePlacementTarget } = await import('./routines-placement.js');
+        const { resolvePlacementTarget } = await import('../routines-placement.js');
         const target = await resolvePlacementTarget(config);
         if (target.mode === 'host' || target.mode === 'cloud') {
             await assertRoutineAccountLocalForPlacement(config, target.mode);
@@ -1798,7 +1739,7 @@ async function executeJobDetachedClaimed(config, attempt, hooks) {
         ? buildSpawnEnv(overlayHome, config.env)
         : { ...process.env }, config);
     if (!dispatchesViaAgentsRun(config)) {
-        const { findAccount, resolveAccountSelection, resolveCredentialAccount } = await import('./account-registry.js');
+        const { findAccount, resolveAccountSelection, resolveCredentialAccount } = await import('../account-registry.js');
         const selectedAccount = config.account && !findAccount(config.account)
             ? undefined
             : resolveAccountSelection(config.account, config.agent, readMeta());

package/dist/lib/daemon-webhooks.d.ts

@@ -23,7 +23,9 @@ export interface HostedReceiverFunnel {
 }
 /** One receiver this box hosts. */
 export interface HostedReceiverConfig {
-    /** Secrets bundle holding GITHUB_WEBHOOK_SECRET and/or LINEAR_WEBHOOK_SECRET. */
+    /** Secrets bundle holding GITHUB_WEBHOOK_SECRET, LINEAR_WEBHOOK_SECRET, and/or
+     *  SLACK_SIGNING_SECRET (a Slack receiver also carries SLACK_BOT_TOKEN when the
+     *  agent replies with the Slack Web API rather than `agents send`). */
     bundle: string;
     /** Local bind port (default 8787). */
     port?: number;

package/dist/lib/daemon-webhooks.js

@@ -112,8 +112,10 @@ export function resolveReceiverSecrets(bundle) {
         secrets.github = env.GITHUB_WEBHOOK_SECRET;
     if (env.LINEAR_WEBHOOK_SECRET)
         secrets.linear = env.LINEAR_WEBHOOK_SECRET;
-    if (!secrets.github && !secrets.linear) {
-        throw new Error(`bundle '${bundle}' has neither GITHUB_WEBHOOK_SECRET nor LINEAR_WEBHOOK_SECRET`);
+    if (env.SLACK_SIGNING_SECRET)
+        secrets.slack = env.SLACK_SIGNING_SECRET;
+    if (!secrets.github && !secrets.linear && !secrets.slack) {
+        throw new Error(`bundle '${bundle}' has none of GITHUB_WEBHOOK_SECRET, LINEAR_WEBHOOK_SECRET, or SLACK_SIGNING_SECRET`);
     }
     return secrets;
 }
@@ -176,12 +178,15 @@ export async function startHostedWebhookReceivers(opts) {
                 // Per-port durable delivery dedup so replays survive a daemon restart and
                 // two receivers on distinct ports never share a dedup ledger.
                 deliveryStore: createFileDeliveryStore(path.join(getRuntimeStateDir(), 'webhook', `deliveries-${port}.json`)),
-                onDelivery: (webhook, fired, handlers) => {
+                // Logged at MATCH time, before dispatch — a `run.command` handler can
+                // block on a shelled-out agent run for minutes, and that must never
+                // delay the log that says a delivery fired (RUSH-2722).
+                onMatch: (webhook, matchedJobNames, matchedHandlerNames) => {
                     const parts = [];
-                    if (fired.length)
-                        parts.push(`routines ${fired.map((f) => f.jobName).join(', ')}`);
-                    if (handlers.length)
-                        parts.push(`handlers ${handlers.map((h) => h.handlerName).join(', ')}`);
+                    if (matchedJobNames.length)
+                        parts.push(`routines ${matchedJobNames.join(', ')}`);
+                    if (matchedHandlerNames.length)
+                        parts.push(`handlers ${matchedHandlerNames.join(', ')}`);
                     log('INFO', `webhook ${webhook.source}:${webhook.event} ${parts.length ? `fired ${parts.join('; ')}` : 'no match'}`);
                 },
                 // The 202 ack means no HTTP status carries a settle failure — the daemon

package/dist/lib/device-config.js

@@ -96,7 +96,7 @@ export const CONFIG_KEYS = [
         scope: 'device',
         visibility: 'machine',
         type: 'string',
-        description: 'Browser profile `agents browser start` resolves to without --profile (set via `agents browser profiles set-default`).',
+        description: 'Browser profile `agents browser start` resolves to without --profile (set via `agents browser use`).',
     },
     {
         name: 'agents.max-concurrent',

package/dist/lib/devices/doctor-findings.d.ts

@@ -1,5 +1,5 @@
 import type { AgentId } from '../types.js';
-import type { DuplicateVersionHook } from '../hooks.js';
+import type { DuplicateVersionHook } from '../hooks/install.js';
 import type { AgentsBinaryShadow } from '../binary-shadow.js';
 import type { RcSecretFinding } from '../secrets/rc-hygiene.js';
 import type { OwnerSinkStatus } from '../channels/owner-sink.js';

package/dist/lib/devices/doctor-findings.js

@@ -41,13 +41,13 @@ import chalk from 'chalk';
 import { AGENTS, ALL_AGENT_IDS, supportsAccountInspection } from '../agents.js';
 import { blocksLocalScripts } from '../platform/winpath.js';
 import { loginHint } from '../signin-badge.js';
-import { CONFIG_ENV_ISOLATED_AGENTS } from '../shims.js';
+import { CONFIG_ENV_ISOLATED_AGENTS } from '../installations/shims.js';
 import { padToWidth, stringWidth } from '../session/width.js';
 import { windowsSshEnrollmentProblem } from './windows-ssh-enrollment.js';
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
 /** Agents with NO per-version credential isolation: their login is shared across
  *  every installed version, so a "log into THIS version" remediation would be a
- *  lie. Derived from `CONFIG_ENV_ISOLATED_AGENTS` in `lib/shims.ts` — the shim
+ *  lie. Derived from `CONFIG_ENV_ISOLATED_AGENTS` in `lib/installations/shims.ts` — the shim
  *  generator is what actually exports the per-version isolation env var, so it is
  *  the source of truth. Do not hand-maintain a second copy: an agent gaining
  *  isolation there must not leave a stale "login is shared" hint here. */
@@ -193,7 +193,7 @@ export function remediationFor(finding) {
             }
             // Isolated per-version home: the login must RUN INSIDE that home. A bare
             // `<cli> login` afterwards would NOT — the native shim resolves to the
-            // project/default version (`lib/shims.ts:471-474`), so it would log into
+            // project/default version (`lib/installations/shims.ts:471-474`), so it would log into
             // whichever version is default, not the one that is logged out.
             switch (loginShape(agent)) {
                 case 'subcommand':

package/dist/lib/devices/fleet-inventory.js

@@ -10,7 +10,7 @@
  */
 import { getAvailableResources, getVersionHomePath, isVersionIsolated, listInstalledVersions } from '../installations/versions.js';
 import { supports } from '../capabilities.js';
-import { checkVersionHookWiring } from '../hooks.js';
+import { checkVersionHookWiring } from '../hooks/install.js';
 import { getUserAgentsDir, getSystemAgentsDir, readMeta } from '../state.js';
 import { listNativeAccounts } from '../account-registry.js';
 import { readRepoState } from '../git.js';

package/dist/lib/devices/harness-inventory.js

@@ -16,7 +16,7 @@
 import chalk from 'chalk';
 import { ALL_AGENT_IDS, accountDisplayLabel, getAccountInfo, } from '../agents.js';
 import { deriveUsageStatusFromSnapshot, getUsageInfoByIdentity, getUsageLookupKey, } from '../accounting/usage.js';
-import { getVersionHomePath, listInstalledVersions } from '../installations/versions.js';
+import { getVersionHomePath, listInstalledVersions } from '../installations/store.js';
 import { readMeta } from '../state.js';
 import { listNativeAccounts } from '../account-registry.js';
 /**

package/dist/lib/devices/registry.js

@@ -16,9 +16,9 @@
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as path from 'path';
-import { randomBytes } from 'crypto';
 import lockfile from 'proper-lockfile';
 import { getDevicesRegistryPath, getDevicesIgnoredPath } from '../state.js';
+import { atomicWriteJsonSync } from '../fs-atomic.js';
 /** A device's effective role, defaulting to `worker` when unset. */
 export function deviceRole(d) {
     return d.role ?? 'worker';
@@ -94,24 +94,6 @@ export function platformFromOs(os) {
 export function shellForPlatform(platform) {
     return platform === 'windows' ? 'powershell' : 'posix';
 }
-/**
- * Atomic JSON write: write to a unique sibling tmp file then rename over the
- * target. rename(2) is atomic on POSIX, so a crashed write leaves the old file
- * untouched instead of producing a half-written registry that loadDevices()
- * would reject.
- */
-async function atomicWriteJson(p, data) {
-    await fs.mkdir(path.dirname(p), { recursive: true });
-    const tmp = `${p}.tmp.${process.pid}.${randomBytes(4).toString('hex')}`;
-    await fs.writeFile(tmp, JSON.stringify(data, null, 2));
-    try {
-        await fs.rename(tmp, p);
-    }
-    catch (err) {
-        await fs.unlink(tmp).catch(() => { });
-        throw err;
-    }
-}
 /**
  * Run `fn` while holding an exclusive cross-process lock on the registry file.
  * proper-lockfile requires the target to exist, so we touch it first. Stale
@@ -187,7 +169,7 @@ export function loadDevicesSync() {
     }
 }
 async function saveDevices(reg) {
-    await atomicWriteJson(registryPath(), reg);
+    atomicWriteJsonSync(registryPath(), reg);
 }
 /** Get a single device profile, or null if it is not registered. */
 export async function getDevice(name) {
@@ -309,7 +291,7 @@ export async function addIgnored(name) {
     return withRegistryLock(p, async () => {
         const set = await loadIgnored();
         set.add(name);
-        await atomicWriteJson(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
+        atomicWriteJsonSync(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
         return set;
     });
 }
@@ -321,7 +303,7 @@ export async function removeIgnored(name) {
         const set = await loadIgnored();
         if (!set.delete(name))
             return false;
-        await atomicWriteJson(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
+        atomicWriteJsonSync(p, { ignored: [...set].sort(), updatedAt: new Date().toISOString() });
         return true;
     });
 }

package/dist/lib/doctor-diff.d.ts

@@ -21,7 +21,7 @@
  */
 import type { AgentId } from './types.js';
 import type { DiscoveredPlugin } from './types.js';
-import { type HookWiringReport } from './hooks.js';
+import { type HookWiringReport } from './hooks/install.js';
 import { type ResourceInventory } from './resource-inventory.js';
 export type DoctorKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'promptcuts';
 export type DiffStatus = 'ok' | 'diff' | 'missing' | 'extra';

package/dist/lib/doctor-diff.js

@@ -33,7 +33,7 @@ import { shouldInstallCommandAsSkill, commandSkillMatches, commandSkillName } fr
 import { gooseCommandMatches, gooseCommandsDir } from './goose-commands.js';
 import { supports } from './capabilities.js';
 import { listSkillsInVersionHome, getVersionSkillsDir } from './plugins/skills.js';
-import { listHookEntriesFromDir } from './hooks.js';
+import { listHookEntriesFromDir } from './hooks/install.js';
 import { getResourceInventory } from './resource-inventory.js';
 const RULES_DOC_FILENAME = 'README.md';
 const ALL_KINDS = [

package/dist/lib/drift.js

@@ -4,7 +4,7 @@ import { loadManifest, isStale } from './staleness/index.js';
 import { diffVersionResources } from './doctor-diff.js';
 import { diffVersionCommands, iterCommandsCapableVersions } from './commands.js';
 import { diffVersionSkills, iterSkillsCapableVersions } from './plugins/skills.js';
-import { iterHooksCapableVersions, listUnmanagedHooksInVersionHome, checkVersionHookWiring } from './hooks.js';
+import { iterHooksCapableVersions, listUnmanagedHooksInVersionHome, checkVersionHookWiring } from './hooks/install.js';
 import { commitsBehindUpstream } from './git.js';
 import { getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos } from './state.js';
 // Lines naming exactly what's out of sync for a version, plugins prioritized:

package/dist/lib/entitlement.d.ts

@@ -0,0 +1,31 @@
+/** How long a cached tier is trusted before the next call re-fetches. */
+export declare const ENTITLEMENT_CACHE_TTL_MS: number;
+export type EntitlementSource = 'live' | 'cache' | 'offline' | 'no-session';
+export interface EntitlementTier {
+    /** The raw tier name from the backend ('free', 'admin', or a paid tier name). */
+    tierName: string;
+    /** true for 'admin' or any tier name other than 'free'. */
+    isPaid: boolean;
+    /** Where this value came from — mainly for diagnostics/tests. */
+    source: EntitlementSource;
+}
+export declare function setEntitlementUserYamlPathForTest(value: string | null): void;
+export declare function setEntitlementCachePathForTest(value: string | null): void;
+export declare function setEntitlementFetchForTest(fn: typeof globalThis.fetch): void;
+export declare function entitlementCachePath(): string;
+/**
+ * The live plan tier, cache-first with a TTL.
+ *
+ * - No `~/.rush/user.yaml` at all → free, no network call.
+ * - A fresh cache entry (within {@link ENTITLEMENT_CACHE_TTL_MS}) is returned
+ *   with no network call.
+ * - A stale or missing cache triggers a live fetch; on success the result is
+ *   cached and returned.
+ * - A failed fetch (offline, timeout, non-2xx) falls back to a stale cache if
+ *   one exists — never silently drops a known-paid account to free just
+ *   because the network hiccuped — and only falls back to free when there is
+ *   no cache at all to fall back to.
+ */
+export declare function getTier(): Promise<EntitlementTier>;
+/** Per-harness account cap for a tier: 3 on free, 10 on paid/admin. */
+export declare function accountCapForTier(tier: Pick<EntitlementTier, 'isPaid'>): number;