@phnx-labs/agents-cli 1.22.41 → 1.22.43

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

@@ -17,29 +17,30 @@ 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, 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 { 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, assertSandboxForwardsHostGhAuth } 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, 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_IDS, isAgentHardDeprecated, hardDeprecationError } from '../agents.js';
+import { isCustomHarnessName, readProfile } from '../profiles.js';
 export class RoutineAlreadyRunningError extends Error {
     constructor(jobName, runId) {
         super(`Routine '${jobName}' already has a running execution (${runId})`);
@@ -308,7 +309,7 @@ function allocateRoutineAttempt(config, trigger) {
     // harness leaves the command table (gemini did), and the legacy routine must
     // still land a visible 'blocked' record, never a generic buildJobCommand
     // failure (RUSH-2202).
-    if (!config.workflow && config.agent && isAgentHardDeprecated(config.agent)) {
+    if (!config.workflow && config.agent && !isCustomHarnessName(config.agent) && isAgentHardDeprecated(config.agent)) {
         const reason = hardDeprecationError(config.agent);
         return {
             proceed: false,
@@ -488,6 +489,48 @@ export function routineSpawnCwd(config) {
     const ctx = resolveJobExecutionContext(config, { mode: 'local' });
     return ctx.absoluteCwd ?? os.homedir();
 }
+/**
+ * Bake the daemon-job argv skeleton from AGENT_COMMANDS.
+ *
+ * The two tables used to be independent copies of the same launch decision.
+ * Argv now comes from AGENT_COMMANDS.base / promptFlag / jsonFlags / modeFlags.
+ * Two documented exceptions, not a second table:
+ *   - kimi uses `--prompt` (long form). `-p` is the exec alias; combining
+ *     either with --plan/--auto/--yolo aborts, so routineModeArgs emits no
+ *     mode flag. The daemon has always spawned the long form.
+ *   - claude places `--verbose` (from jsonFlags) before the prompt and bakes
+ *     modeFlags.plan so claudeAdapter.routineModeArgs can splice
+ *     plan → acceptEdits / auto / skip.
+ *
+ * Returns undefined when `agent` is outside ROUTINE_AGENT_IDS (gemini, grok,
+ * and every other harness the daemon does not fire locally).
+ */
+export function bakeRoutineArgv(agent) {
+    if (!ROUTINE_AGENT_IDS.includes(agent))
+        return undefined;
+    const template = AGENT_COMMANDS[agent];
+    if (!template)
+        return undefined;
+    const json = template.jsonFlags ?? [];
+    const cmd = [...template.base];
+    if (agent === 'kimi') {
+        cmd.push('--prompt', '{prompt}', ...json);
+        return cmd;
+    }
+    if (agent === 'claude') {
+        const verbose = json.includes('--verbose') ? ['--verbose'] : [];
+        const jsonRest = json.filter((flag) => flag !== '--verbose');
+        cmd.push(template.promptFlag, ...verbose, '{prompt}', ...jsonRest, ...(template.modeFlags.plan ?? []));
+        return cmd;
+    }
+    if (template.promptFlag === 'positional') {
+        cmd.push('{prompt}', ...json);
+    }
+    else {
+        cmd.push(template.promptFlag, '{prompt}', ...json);
+    }
+    return cmd;
+}
 /** Build the full CLI argv for executing a job, applying mode, model, and permission flags. */
 export function buildJobCommand(config, resolvedPrompt, forwardAccount = true) {
     // Workflow branch: delegate to `agents run <workflow>` which handles subagent
@@ -514,94 +557,36 @@ export function buildJobCommand(config, resolvedPrompt, forwardAccount = true) {
             cmd.push('--account', config.account);
         return cmd;
     }
-    const template = ROUTINE_AGENT_COMMANDS[agent];
+    // Custom-harness branch: delegate to `agents run <name>`, which owns profile
+    // resolution (host binary, model env, provider auth) — the same delegation
+    // the workflow and resume branches use. The profile pins its own version and
+    // auth, so no command template, binary pinning, or account-env injection
+    // applies here.
+    if (isCustomHarnessName(agent)) {
+        const cmd = ['agents', 'run', agent, resolvedPrompt, '--mode', config.mode];
+        if (config.account && forwardAccount)
+            cmd.push('--account', config.account);
+        return cmd;
+    }
+    const template = bakeRoutineArgv(agent);
     if (!template) {
-        throw new Error(`Unsupported agent for daemon jobs: ${agent}`);
+        // A name outside both tables was either never valid or was a custom
+        // harness whose profile has since been deleted — validateJob accepted it
+        // against a profile that existed then. Name the repair, not just the miss.
+        throw new Error(`Unsupported agent for daemon jobs: ${agent}. ` +
+            `If '${agent}' was a custom harness, its profile no longer exists on this device — ` +
+            `recreate it (agents harness add ${agent} ...) or point the routine at another 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
@@ -628,7 +613,8 @@ export function buildJobCommand(config, resolvedPrompt, forwardAccount = true) {
  * Reasoning level (config.config.reasoning) maps to per-agent flags via models.ts.
  */
 function appendModelAndReasoning(cmd, config) {
-    // Only called from buildJobCommand's agent path — config.agent is set.
+    // Only called from buildJobCommand's agent path AFTER the custom-harness
+    // branch returned — config.agent is a native id here.
     const agent = config.agent;
     const model = config.config?.model;
     if (model) {
@@ -710,6 +696,8 @@ function transcriptBasePath(runDir) {
 export function snapshotRoutineTranscriptBase(meta, runDir, overlayHome) {
     if (!meta.agent)
         return;
+    // A host/cloud custom-harness run records the harness name, which has no
+    // transcript spec — the null-specs guard below skips it, as before.
     const specs = ROUTINE_TRANSCRIPT_SPECS[meta.agent];
     if (!specs)
         return;
@@ -748,6 +736,8 @@ function readTranscriptBase(runDir) {
 export function archiveRoutineTranscripts(meta, runDir, overlayHome) {
     if (!meta.agent)
         return;
+    // A host/cloud custom-harness run records the harness name, which has no
+    // transcript spec — the null-specs guard below skips it, as before.
     const specs = ROUTINE_TRANSCRIPT_SPECS[meta.agent];
     if (!specs)
         return;
@@ -882,10 +872,17 @@ export async function resolveRoutineLaunch(config, cwd = process.cwd(), deps = {
     if (config.workflow) {
         return { chain: [], rotation: null, pinned: false };
     }
+    if (config.agent && isCustomHarnessName(config.agent)) {
+        // A custom harness pins its own version/auth in the profile, so there is
+        // no version/account chain to resolve here — `agents run <name>` owns it
+        // (matching exec's "strategy ignored: custom harness pins its own
+        // version/auth").
+        return { chain: [], rotation: null, pinned: false };
+    }
     // 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))
@@ -1041,7 +1038,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) {
@@ -1086,7 +1083,7 @@ export function buildHostDispatchOptions(config, ctx) {
     };
 }
 export function dispatchesViaAgentsRun(config) {
-    return Boolean(config.workflow || config.resume);
+    return Boolean(config.workflow || config.resume || (config.agent && isCustomHarnessName(config.agent)));
 }
 /**
  * Merge sandbox/base env with the canonical per-version exec env
@@ -1261,7 +1258,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)
@@ -1288,7 +1285,11 @@ async function executeJobPlaced(config, deps, attempt) {
     // the agent's config dir, and the sandbox overlay home has only a freshly-generated
     // config with no session store. So a resume job is never sandboxed, regardless of
     // `config.sandbox` (see the resume branch in buildJobCommand).
-    const useSandbox = config.sandbox !== false && !config.resume;
+    // Resume needs the REAL home (session store); a custom harness needs it too —
+    // the delegated `agents run <name>` resolves ~/.agents (profiles, setup
+    // sentinel, version homes) from HOME, which the overlay would hide. Exec
+    // still isolates the run in the host version home it swaps HOME into.
+    const useSandbox = config.sandbox !== false && !config.resume && !(config.agent && isCustomHarnessName(config.agent));
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = attempt.runId;
     const runDir = getRunDir(config.name, runId);
@@ -1299,9 +1300,13 @@ async function executeJobPlaced(config, deps, attempt) {
     // Workflows run via `agents run <workflow>` which delegates to claude under the hood.
     // Use 'claude' as the effective agent for report extraction and metadata when workflow is set.
     // (command jobs branched out earlier, so config.agent is set on the non-workflow path.)
-    const effectiveAgent = config.workflow ? 'claude' : config.agent;
+    const effectiveAgent = config.workflow
+        ? 'claude'
+        : isCustomHarnessName(config.agent)
+            ? readProfile(config.agent).host.agent
+            : 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) {
@@ -1312,6 +1317,9 @@ async function executeJobPlaced(config, deps, attempt) {
                 Object.assign(baseEnv, resolveCredentialAccount(selectedAccount, effectiveAgent).env);
         }
     }
+    // RUSH-2860: if this host holds gh auth, the sandbox child MUST see it.
+    if (useSandbox)
+        assertSandboxForwardsHostGhAuth(baseEnv);
     const meta = {
         jobName: config.name,
         runId,
@@ -1374,7 +1382,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,
@@ -1530,8 +1538,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,
@@ -1604,9 +1612,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'}`);
@@ -1754,7 +1762,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);
@@ -1802,7 +1810,11 @@ async function executeJobDetachedClaimed(config, attempt, hooks) {
     // the agent's config dir, and the sandbox overlay home has only a freshly-generated
     // config with no session store. So a resume job is never sandboxed, regardless of
     // `config.sandbox` (see the resume branch in buildJobCommand).
-    const useSandbox = config.sandbox !== false && !config.resume;
+    // Resume needs the REAL home (session store); a custom harness needs it too —
+    // the delegated `agents run <name>` resolves ~/.agents (profiles, setup
+    // sentinel, version homes) from HOME, which the overlay would hide. Exec
+    // still isolates the run in the host version home it swaps HOME into.
+    const useSandbox = config.sandbox !== false && !config.resume && !(config.agent && isCustomHarnessName(config.agent));
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = attempt.runId;
     const runDir = getRunDir(config.name, runId);
@@ -1813,7 +1825,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());
@@ -1829,7 +1841,15 @@ async function executeJobDetachedClaimed(config, attempt, hooks) {
         })()
         // Non-command path only: config.agent is always set here (command/workflow branch earlier).
         : buildRoutineSpawnEnv(baseEnv, config.agent, version, config.timezone, overlayHome);
-    const effectiveAgent = config.workflow ? 'claude' : config.agent;
+    // RUSH-2860: if this host holds gh auth, the sandbox child MUST see it —
+    // otherwise monitors runs records ok while every gh call inside fails.
+    if (useSandbox)
+        assertSandboxForwardsHostGhAuth(spawnEnv);
+    const effectiveAgent = config.workflow
+        ? 'claude'
+        : isCustomHarnessName(config.agent)
+            ? readProfile(config.agent).host.agent
+            : config.agent;
     const meta = {
         jobName: config.name,
         runId,

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 { padToWidth, stringWidth } from '../session/width.js';
+import { CONFIG_ENV_ISOLATED_AGENTS } from '../installations/shims.js';
+import { padToWidth, stringWidth } from '../text/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/health-report.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { padToWidth, stringWidth, terminalWidth, truncateToWidth } from '../session/width.js';
+import { padToWidth, stringWidth, terminalWidth, truncateToWidth } from '../text/width.js';
 import { fmtBytes, headroom } from './health.js';
 import { formatCheckedAge } from '../auth-health.js';
 import { compareFleetInventories } from './fleet-divergence.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-sync.d.ts

@@ -1,6 +1,6 @@
 /**
  * Interactive drift-sync flow — the single "we detected drift, want to fix it?"
- * action, shared by `agents status`, `agents doctor`, and the menu-bar "NEEDS
+ * action, shared by `agents sync status`, `agents doctor`, and the menu-bar "NEEDS
  * SYNC" row.
  *
  * It composes existing pieces, re-implementing nothing:

package/dist/lib/drift-sync.js

@@ -1,6 +1,6 @@
 /**
  * Interactive drift-sync flow — the single "we detected drift, want to fix it?"
- * action, shared by `agents status`, `agents doctor`, and the menu-bar "NEEDS
+ * action, shared by `agents sync status`, `agents doctor`, and the menu-bar "NEEDS
  * SYNC" row.
  *
  * It composes existing pieces, re-implementing nothing:
@@ -115,7 +115,7 @@ export async function promptDriftSync(opts = {}) {
     if (opts.yes || !isInteractiveTerminal()) {
         if (!opts.yes) {
             // Non-TTY without --yes: report, don't act, don't throw.
-            console.log(chalk.gray('\nRun `agents status --yes` to sync, or `agents status` in a terminal to choose.'));
+            console.log(chalk.gray('\nRun `agents sync status --yes` to sync, or `agents sync status` in a terminal to choose.'));
             return base;
         }
         const systemPulled = await pullSystem(status);

package/dist/lib/drift.d.ts

@@ -62,7 +62,7 @@ export interface DriftSummary {
      * True when the install is out of sync: any installed version is stale,
      * never-synced, carries unwired hooks, or has a broken generated hook runtime,
      * OR a source layer is behind origin.
-     * `agents doctor` surfaces it as "run `agents status`"; `agents doctor --check`
+     * `agents doctor` surfaces it as "run `agents sync status`"; `agents doctor --check`
      * maps it to a non-zero exit. Orphans are a `prune` concern, not sync drift, so they do
      * NOT set this flag (mirrors the sync-status engine: an orphan alone never
      * flags needsSync).

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: