@phnx-labs/agents-cli 1.22.41 → 1.22.43

package/dist/lib/harness/adapters/codex.js

@@ -0,0 +1,83 @@
+import * as os from 'os';
+import * as path from 'path';
+import { getHistoryDir } from '../../state.js';
+import { resolveCodexHome, codexHomeShimBash } from '../../codex-home.js';
+import { codexEditWritableRoots, codexPolicyArgs } from '../../codex-policy.js';
+import { stripForeignConfigDir } from '../adapter.js';
+/**
+ * Shim-script single-quoting — identical to the local `shellQuote` in shims.ts
+ * (always wraps in single quotes), NOT ssh-exec's variant (which leaves
+ * shell-safe strings unquoted). The generated shim's codex launch args must stay
+ * byte-for-byte what shims.ts produced, so the quoting moves with the logic.
+ */
+function shimShellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export const codexAdapter = {
+    id: 'codex',
+    applyExecConfigEnv(result, ctx) {
+        if (ctx.version && ctx.versionHome) {
+            // On macOS the deep versioned home overflows the Unix-socket SUN_LEN
+            // limit for codex's app-server control socket; resolve to a short,
+            // SUN_LEN-safe home (migrating once if needed). See codex-home.ts.
+            const versionedHome = path.join(ctx.versionHome, '.codex');
+            const agentsUserDir = path.dirname(getHistoryDir());
+            result.CODEX_HOME = resolveCodexHome(versionedHome, agentsUserDir, ctx.version);
+        }
+        stripForeignConfigDir(result, ['CODEX_HOME']);
+    },
+    shimConfigEnvBash(ctx) {
+        return codexHomeShimBash(`$VERSION_DIR/home/${ctx.configDirName}`, `$AGENTS_USER_DIR/.codex-homes/$VERSION`);
+    },
+    shimLaunchArgs() {
+        return ` ${[
+            '-c',
+            'check_for_update_on_startup=false',
+            ...codexPolicyArgs('edit'),
+        ].map(shimShellQuote).join(' ')}`;
+    },
+    shimExecTail(launchArgs) {
+        // Codex is special: its `workspace-write` sandbox hardcodes any `.agents/`
+        // (and `.codex/`) directory read-only, but agents-cli keeps every worktree at
+        // `<repo>/.agents/worktrees/<slug>`, so an in-repo build under a static shim
+        // would hit `EROFS`. The shim resolves the repo's `.agents` from `$PWD` at RUN
+        // time — worktree-aware, mirroring repoAgentsDirForCwd — and passes it via
+        // Codex's own `--add-dir`. `--add-dir` is added only when the resolved
+        // `.agents` exists.
+        return `_repo_agents=""
+case "$PWD" in
+  */.agents/worktrees/*) _repo_agents="\${PWD%%/.agents/worktrees/*}/.agents" ;;
+  *)
+    _d="$PWD"
+    # Stop before $HOME so a dotfiles repo at $HOME is not treated as the project
+    # root (mirrors repoRootForCwd's home exclusion in project-key.ts).
+    while [ -n "$_d" ] && [ "$_d" != "/" ] && [ "$_d" != "$HOME" ]; do
+      if [ -e "$_d/.git" ]; then _repo_agents="$_d/.agents"; break; fi
+      _d=$(dirname "$_d")
+    done
+    ;;
+esac
+if [ -n "$_repo_agents" ] && [ -d "$_repo_agents" ]; then
+  exec "$BINARY"${launchArgs} --add-dir "$_repo_agents" "$@"
+fi
+exec "$BINARY"${launchArgs} "$@"`;
+    },
+    execModeArgs(ctx) {
+        const policyMode = ctx.resolvedMode === 'plan' || ctx.resolvedMode === 'skip' ? ctx.resolvedMode : 'edit';
+        const writableRoots = [
+            ...codexEditWritableRoots(ctx.cwd),
+            ...ctx.addDirs,
+        ];
+        return codexPolicyArgs(policyMode, writableRoots);
+    },
+    routineModeArgs(cmd, ctx) {
+        const policyMode = ctx.mode === 'plan' || ctx.mode === 'skip' ? ctx.mode : 'edit';
+        const routineRoots = (ctx.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]));
+    },
+};

package/dist/lib/harness/adapters/copilot.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const copilotAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/copilot.js

@@ -0,0 +1,23 @@
+import * as path from 'path';
+import { stripForeignConfigDir } from '../adapter.js';
+export const copilotAdapter = {
+    id: 'copilot',
+    // Copilot honors COPILOT_HOME (relocates ~/.copilot, including settings,
+    // mcp-config.json, sessions, logs). Pin it at the per-version home so
+    // version switches isolate MCP servers, auth, and session history.
+    applyExecConfigEnv(result, ctx) {
+        if (ctx.versionHome) {
+            result.COPILOT_HOME = path.join(ctx.versionHome, '.copilot');
+        }
+        stripForeignConfigDir(result, ['COPILOT_HOME']);
+    },
+    shimConfigEnvBash(ctx) {
+        return `
+# GitHub Copilot CLI honors COPILOT_HOME to relocate its config and state
+# (settings.json, mcp-config.json, session-state/, logs/, plugins/). Point
+# it at the versioned home so MCP servers, custom agents, and session
+# history are isolated per copilot version.
+export COPILOT_HOME="$VERSION_DIR/home/${ctx.configDirName}"
+`;
+    },
+};

package/dist/lib/harness/adapters/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const cursorAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/cursor.js

@@ -0,0 +1,38 @@
+import * as path from 'path';
+import { stripForeignConfigDir } from '../adapter.js';
+export const cursorAdapter = {
+    id: 'cursor',
+    // Cursor has no config-dir env var (only CURSOR_API_KEY / CURSOR_API_ENDPOINT).
+    // Its OAuth token — the login gate — lives at $XDG_CONFIG_HOME/cursor/auth.json
+    // (verified empirically: relocating XDG_CONFIG_HOME relocates the login;
+    // ~/.cursor/cli-config.json holds only account metadata, not the token). Pin
+    // XDG_CONFIG_HOME into the version home so each installed Cursor account
+    // authenticates from its own token, isolated per run — no global ~/.cursor
+    // symlink swap, so concurrent runs on different accounts never clobber one
+    // another. cli-config.json (HOME-relative) has no override and stays on the
+    // shared home; only the token is per-account, which is what gates the login.
+    applyExecConfigEnv(result, ctx) {
+        if (ctx.versionHome) {
+            result.XDG_CONFIG_HOME = path.join(ctx.versionHome, '.config');
+        }
+        stripForeignConfigDir(result);
+    },
+    execPreModeArgs(ctx) {
+        // A configured headless run is the workspace trust decision. Keep this
+        // narrower than --yolo/-f, which also bypasses permission checks.
+        return ctx.resolvedMode === 'edit' && !ctx.interactive ? ['--trust'] : undefined;
+    },
+    routineModeArgs(cmd, ctx) {
+        if (ctx.mode === 'plan') {
+            cmd.push('--plan');
+        }
+        else if (ctx.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');
+        }
+    },
+};

package/dist/lib/harness/adapters/droid.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const droidAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/droid.js

@@ -0,0 +1,17 @@
+// Droid has no config-dir env pin (exec strips the foreign keys via the registry
+// fallback) and no shim config env. Its only harness quirk is routine autonomy.
+export const droidAdapter = {
+    id: 'droid',
+    // droid exec defaults to read-only (plan). Escalate autonomy per mode.
+    routineModeArgs(cmd, ctx) {
+        if (ctx.mode === 'edit') {
+            cmd.push('--auto', 'low');
+        }
+        else if (ctx.mode === 'auto') {
+            cmd.push('--auto', 'high');
+        }
+        else if (ctx.mode === 'skip') {
+            cmd.push('--skip-permissions-unsafe');
+        }
+    },
+};

package/dist/lib/harness/adapters/grok.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const grokAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/grok.js

@@ -0,0 +1,14 @@
+// Grok has no exec-time config-dir env pin (buildExecEnv's `else` strips the
+// foreign keys — the registry fallback preserves that). It DOES relocate its
+// whole config tree via GROK_HOME in the generated shim.
+export const grokAdapter = {
+    id: 'grok',
+    shimConfigEnvBash() {
+        return `
+# Grok Build uses GROK_HOME to isolate its entire configuration tree
+# (skills, hooks, plugins, agents, memory, sessions, config.toml, MCP, etc.).
+# This gives agents-cli full versioned isolation + resource sync for grok.
+export GROK_HOME="$VERSION_DIR/home/.grok"
+`;
+    },
+};

package/dist/lib/harness/adapters/kimi.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const kimiAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/kimi.js

@@ -0,0 +1,49 @@
+import * as path from 'path';
+import { stripForeignConfigDir } from '../adapter.js';
+export const kimiAdapter = {
+    id: 'kimi',
+    // Kimi honors KIMI_CODE_HOME (relocates ~/.kimi-code, including config,
+    // skills, hooks, sessions). Pin it at the per-version home.
+    applyExecConfigEnv(result, ctx) {
+        if (ctx.versionHome) {
+            result.KIMI_CODE_HOME = path.join(ctx.versionHome, '.kimi-code');
+        }
+        stripForeignConfigDir(result, ['KIMI_CODE_HOME']);
+    },
+    shimConfigEnvBash(ctx) {
+        return `
+# Kimi Code CLI honors KIMI_CODE_HOME to relocate ~/.kimi-code (config.toml,
+# mcp.json, sessions, skills, hooks). Point it at the versioned home.
+export KIMI_CODE_HOME="$VERSION_DIR/home/${ctx.configDirName}"
+`;
+    },
+    execModeArgs(ctx) {
+        // kimi's headless prompt mode (`-p`/`--prompt`) is self-contained and REFUSES
+        // to be combined with any startup-mode flag: `--plan`, `--auto`, and `--yolo`
+        // all abort with "Cannot combine --prompt with --X" (verified against the live
+        // kimi CLI). The write-capable modes (edit/auto/skip) all collapse to kimi's
+        // default `-p` behavior, which already auto-approves tool calls, so we emit no
+        // mode flag. An interactive kimi run defers to the generic modeFlags path.
+        if (ctx.interactive)
+            return undefined;
+        // Plan can't reach here headless — resolveHeadlessMode already downgraded it to
+        // auto (kimi's headlessPlan:false); this asserts that invariant so a plan-mode
+        // run can never silently mutate the workspace.
+        if (ctx.resolvedMode === 'plan') {
+            throw new Error(`Internal error: kimi reached headless command build with resolved mode 'plan'; ` +
+                `resolveHeadlessMode should have downgraded it to auto (capabilities.headlessPlan is false).`);
+        }
+        // edit/auto/skip: emit no mode flag — `kimi -p` auto-runs.
+        return [];
+    },
+    routineModeArgs(_cmd, ctx) {
+        // 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.
+        ctx.resolveHeadlessMode('kimi', ctx.mode, false);
+    },
+};

package/dist/lib/harness/adapters/muse.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const museAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/muse.js

@@ -0,0 +1,44 @@
+import * as path from 'path';
+import { stripForeignConfigDir } from '../adapter.js';
+export const museAdapter = {
+    id: 'muse',
+    // Muse has no MUSE_CONFIG_DIR. Config is XDG-based:
+    //   $XDG_CONFIG_HOME/muse  (settings, skills, hooks, auth)
+    //   $XDG_DATA_HOME/muse    (sessions, plugins)
+    // Pin both into the version home so multi-version isolation matches
+    // Claude's CLAUDE_CONFIG_DIR / Codex's CODEX_HOME, and so Muse never
+    // resolves through the adopt-time ~/.config/muse symlink (SymlinkOrReparse).
+    applyExecConfigEnv(result, ctx) {
+        if (ctx.versionHome) {
+            result.XDG_CONFIG_HOME = path.join(ctx.versionHome, '.config');
+            result.XDG_DATA_HOME = path.join(ctx.versionHome, '.local', 'share');
+        }
+        stripForeignConfigDir(result);
+    },
+    shimConfigEnvBash() {
+        return `
+# Muse Code has no MUSE_CONFIG_DIR. It resolves config via XDG:
+#   $XDG_CONFIG_HOME/muse  (settings, skills, hooks, auth)
+#   $XDG_DATA_HOME/muse    (sessions, plugins)
+# Pin XDG into the version home so managed runs never walk the adopt-time
+# ~/.config/muse -> version-home symlink — Muse refuses agent-definition
+# sources that are SymlinkOrReparse (exit 1). Same idea as CLAUDE_CONFIG_DIR.
+export XDG_CONFIG_HOME="$VERSION_DIR/home/.config"
+export XDG_DATA_HOME="$VERSION_DIR/home/.local/share"
+`;
+    },
+    // muse exec: plan ≈ no non-shell writes; auto skips approval prompts but
+    // keeps the OS sandbox; skip is --yolo (no approval, no sandbox, trust).
+    routineModeArgs(cmd, ctx) {
+        if (ctx.mode === 'plan') {
+            cmd.push('--disable-write');
+        }
+        else if (ctx.mode === 'auto') {
+            cmd.push('--disable-approval');
+        }
+        else if (ctx.mode === 'skip') {
+            cmd.push('--yolo');
+        }
+        // edit: default on-request approval + sandbox
+    },
+};

package/dist/lib/harness/adapters/opencode.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessAdapter } from '../adapter.js';
+export declare const opencodeAdapter: HarnessAdapter;

package/dist/lib/harness/adapters/opencode.js

@@ -0,0 +1,14 @@
+// OpenCode has no exec-time config-dir env pin (buildExecEnv's `else` strips the
+// foreign keys — the registry fallback preserves that). It reads config-directory
+// resources from OPENCODE_CONFIG_DIR, pinned in the generated shim.
+export const opencodeAdapter = {
+    id: 'opencode',
+    shimConfigEnvBash() {
+        return `
+# OpenCode reads plugins, agents, commands, and other config-directory
+# resources from OPENCODE_CONFIG_DIR. Point it at the versioned global config
+# tree where agents-cli syncs OpenCode resources.
+export OPENCODE_CONFIG_DIR="$VERSION_DIR/home/.config/opencode"
+`;
+    },
+};

package/dist/lib/harness/exec-config-version.d.ts

@@ -0,0 +1,8 @@
+import type { AgentId } from '../types.js';
+export interface ResolvedConfigVersion {
+    /** The version to pin, or null when unresolved / not installed. */
+    version: string | null;
+    /** The version home for that version, or null. */
+    versionHome: string | null;
+}
+export declare function resolveConfigVersion(agent: AgentId, cwd: string, optionsVersion?: string): ResolvedConfigVersion;

package/dist/lib/harness/exec-config-version.js

@@ -0,0 +1,22 @@
+/**
+ * Shared version resolution for the exec-time config-dir env pin. Every
+ * config-dir harness branch in the old buildExecEnv computed this identically:
+ * an explicit `--version` is used unconditionally; an auto-resolved version is
+ * only pinned when it is actually installed on disk.
+ *
+ * The caller (buildExecEnv) invokes this and passes the result into the adapter
+ * via ExecConfigEnvCtx — the adapters MUST NOT import installations/versions
+ * themselves, because that module imports shims.ts and shims.ts imports the
+ * harness barrel, which would close an import cycle (versions → shims → harness →
+ * adapter → versions). That cycle forced esbuild/tsx to emit CJS for part of the
+ * graph and broke sqlite.ts's top-level await in subprocess-spawning tests.
+ */
+import { getVersionHomePath, isVersionInstalled, resolveVersion } from '../installations/versions.js';
+export function resolveConfigVersion(agent, cwd, optionsVersion) {
+    const resolvedVersion = optionsVersion ?? resolveVersion(agent, cwd);
+    const version = optionsVersion
+        ? resolvedVersion
+        : (resolvedVersion && isVersionInstalled(agent, resolvedVersion) ? resolvedVersion : null);
+    const versionHome = version ? getVersionHomePath(agent, version) : null;
+    return { version: version ?? null, versionHome };
+}

package/dist/lib/harness/index.d.ts

@@ -0,0 +1 @@
+export { type HarnessAdapter, type ExecConfigEnvCtx, type ShimConfigEnvCtx, type ExecLaunchArgsCtx, type RoutineLaunchCtx, CONFIG_DIR_ENV_KEYS, stripForeignConfigDir, registerHarnessAdapter, resolveHarnessAdapter, listHarnessAdapters, } from './adapter.js';

package/dist/lib/harness/index.js

@@ -0,0 +1,34 @@
+/**
+ * Harness adapter barrel — importing this registers every built-in adapter, the
+ * same pattern as lib/channels/providers/index.ts. Consumers import
+ * `resolveHarnessAdapter` from here (not from ./adapter.js directly) so the
+ * registration side-effect has run before the first resolve.
+ *
+ * A harness with no config-env / launch quirks needs no adapter file: every
+ * `AgentId` still resolves (to the id-only default), so call sites never
+ * name-check a harness.
+ */
+import { registerHarnessAdapter } from './adapter.js';
+import { claudeAdapter } from './adapters/claude.js';
+import { codexAdapter } from './adapters/codex.js';
+import { copilotAdapter } from './adapters/copilot.js';
+import { kimiAdapter } from './adapters/kimi.js';
+import { museAdapter } from './adapters/muse.js';
+import { cursorAdapter } from './adapters/cursor.js';
+import { grokAdapter } from './adapters/grok.js';
+import { opencodeAdapter } from './adapters/opencode.js';
+import { droidAdapter } from './adapters/droid.js';
+for (const adapter of [
+    claudeAdapter,
+    codexAdapter,
+    copilotAdapter,
+    kimiAdapter,
+    museAdapter,
+    cursorAdapter,
+    grokAdapter,
+    opencodeAdapter,
+    droidAdapter,
+]) {
+    registerHarnessAdapter(adapter);
+}
+export { CONFIG_DIR_ENV_KEYS, stripForeignConfigDir, registerHarnessAdapter, resolveHarnessAdapter, listHarnessAdapters, } from './adapter.js';

package/dist/lib/{hooks.d.ts → hooks/install.d.ts}

@@ -28,7 +28,7 @@ export declare function toPortableCommand(absPath: string, home?: string, sep?:
  * outside version homes are user-owned and remain untouched.
  */
 export declare function deduplicateVersionHookCommands(commands: string[], activeVersionHome: string): string[];
-import type { AgentId, HookCacheConfig, HookMatches, InstalledHook, ManifestHook } from './types.js';
+import type { AgentId, HookCacheConfig, HookMatches, InstalledHook, ManifestHook } from '../types.js';
 export type HookEntry = {
     name: string;
     scriptPath: string;

package/dist/lib/{hooks.js → hooks/install.js}

@@ -16,10 +16,10 @@ import * as TOML from 'smol-toml';
 import { execFile, execFileSync } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { AGENTS, agentConfigDirName, isAgentHardDeprecated } from './agents.js';
-import { supports, explainSkip, capableAgents } from './capabilities.js';
-import { getHooksDir as getSystemHooksDir, getUserHooksDir, getUserAgentsDir, getSystemAgentsDir, getProjectAgentsDir, getTrashHooksDir, getEnabledExtraRepos, getResolvedRulesDir, getUserRulesDir, getPerfDir } from './state.js';
-import { collectSubruleHooksFromState } from './rules/compose.js';
+import { AGENTS, agentConfigDirName, isAgentHardDeprecated } from '../agents.js';
+import { supports, explainSkip, capableAgents } from '../capabilities.js';
+import { getHooksDir as getSystemHooksDir, getUserHooksDir, getUserAgentsDir, getSystemAgentsDir, getProjectAgentsDir, getTrashHooksDir, getEnabledExtraRepos, getResolvedRulesDir, getUserRulesDir, getPerfDir } from '../state.js';
+import { collectSubruleHooksFromState } from '../rules/compose.js';
 function getCentralHooksDir() { return getUserHooksDir(); }
 /**
  * Resolve a hook script's absolute path. Checks user dir first, then enabled
@@ -267,9 +267,9 @@ function collapseVersionHookEntries(entries, activeVersionHome) {
         return true;
     });
 }
-import { getEffectiveHome, getGlobalDefault, getVersionHomePath, isVersionIsolated, listInstalledVersions, resolveVersion, } from './installations/versions.js';
-import { generateHookShim, getHookShimPath, isValidHookShimName, parseCacheConfig, removeHookShim } from './hooks/cache.js';
-import { getHookShimsDir } from './state.js';
+import { getEffectiveHome, getGlobalDefault, getVersionHomePath, isVersionIsolated, listInstalledVersions, resolveVersion, } from '../installations/versions.js';
+import { generateHookShim, getHookShimPath, isValidHookShimName, parseCacheConfig, removeHookShim } from './cache.js';
+import { getHookShimsDir } from '../state.js';
 function hookContentHash(scriptPath) {
     return crypto.createHash('sha256').update(fs.readFileSync(scriptPath)).digest('hex');
 }
@@ -3250,13 +3250,13 @@ function registerHooksForHermes(versionHome, manifest, resolveScript, managedPre
 const execFileAsync = promisify(execFile);
 function resolveSessionTrackerRoot() {
     const here = path.dirname(fileURLToPath(import.meta.url));
-    // Built/installed layout: dist/lib/ -> dist/session-tracker
-    const built = path.resolve(here, '..', 'session-tracker');
+    // Built/installed layout: dist/lib/hooks/ -> dist/session-tracker
+    const built = path.resolve(here, '..', '..', 'session-tracker');
     if (fs.existsSync(path.join(built, 'dist', 'hook.sh'))) {
         return built;
     }
-    // Source layout: apps/cli/src/lib/ -> repo root -> packages/session-tracker
-    const source = path.resolve(here, '..', '..', '..', '..', 'packages', 'session-tracker');
+    // Source layout: apps/cli/src/lib/hooks/ -> repo root -> packages/session-tracker
+    const source = path.resolve(here, '..', '..', '..', '..', '..', 'packages', 'session-tracker');
     if (fs.existsSync(path.join(source, 'src', 'hook.sh'))) {
         return source;
     }

package/dist/lib/hosts/passthrough.d.ts

@@ -48,6 +48,16 @@ export declare const REMOTE_PASSTHROUGH: Record<string, RemoteSpec>;
  * these to {@link REMOTE_PASSTHROUGH}.
  */
 export declare const OWN_HOST_COMMANDS: Set<string>;
+/**
+ * Argv forwarded over SSH for a `--device` passthrough.
+ *
+ * `sync`'s umbrella spec appends `--yes` when there is no TTY so a remote
+ * reconcile does not hang on a picker. `sync status` is inspect-only unless the
+ * caller typed `--yes` themselves: `--yes` on that command is reconcile, not
+ * "don't prompt". Nesting it under `sync` must not inherit the umbrella flag
+ * (RUSH-2864).
+ */
+export declare function buildPassthroughForwardedArgs(command: string, allArgs: string[], interactive: boolean): string[];
 /** Injectable dependencies for {@link runFleetPassthrough} — used by tests. */
 export interface FleetPassthroughOptions {
     /** Override the device registry loader (tests). */

package/dist/lib/hosts/passthrough.js

@@ -52,11 +52,10 @@ export { flagValue, hasHostRoutingFlag } from './routing-flag.js';
  * `add`/`use`/`list`, and none) and were removed.
  */
 export const REMOTE_PASSTHROUGH = {
-    // status / inspect
+    // inspect
     view: {},
     inspect: {},
     doctor: {},
-    status: {},
     check: {},
     list: {},
     usage: {},
@@ -81,7 +80,6 @@ export const REMOTE_PASSTHROUGH = {
     workflows: {},
     models: {},
     defaults: {},
-    alias: {},
     // Installations are per-machine, so updating one on a peer means running it
     // there — the same local/remote shape `add` would need.
     update: {},
@@ -137,6 +135,32 @@ const STRIP_SPECS = [
     { long: 'hosts', takesValue: true },
     { long: 'devices', takesValue: true },
 ];
+/** First non-flag token after `group` in argv (the subcommand, robust to leading flags). */
+function firstSubcommand(allArgs, group) {
+    const idx = allArgs.indexOf(group);
+    return idx >= 0 ? allArgs.slice(idx + 1).find((a) => !a.startsWith('-')) : undefined;
+}
+/**
+ * Argv forwarded over SSH for a `--device` passthrough.
+ *
+ * `sync`'s umbrella spec appends `--yes` when there is no TTY so a remote
+ * reconcile does not hang on a picker. `sync status` is inspect-only unless the
+ * caller typed `--yes` themselves: `--yes` on that command is reconcile, not
+ * "don't prompt". Nesting it under `sync` must not inherit the umbrella flag
+ * (RUSH-2864).
+ */
+export function buildPassthroughForwardedArgs(command, allArgs, interactive) {
+    const spec = REMOTE_PASSTHROUGH[command];
+    let forwarded = stripRoutingFlags(allArgs, STRIP_SPECS);
+    // Detect the subcommand on the *stripped* argv. On the raw argv,
+    // `sync --device peer status` would treat `peer` as the first non-flag
+    // token and inherit umbrella `--yes` (RUSH-2864 review).
+    const skipInheritedYes = command === 'sync' && firstSubcommand(forwarded, 'sync') === 'status';
+    if (!interactive && spec?.nonInteractive && !skipInheritedYes) {
+        forwarded = [...forwarded, ...spec.nonInteractive];
+    }
+    return forwarded;
+}
 /** Synthesize a `Host` for a raw `user@host` / bare-alias target (not enrolled). */
 function syntheticHost(target) {
     const at = target.indexOf('@');
@@ -531,9 +555,7 @@ export async function maybeRunOnHost(command, allArgs, opts) {
     // out — otherwise force the command's non-interactive path so no half-drawn
     // picker is piped into a file or another program.
     const interactive = !!process.stdout.isTTY && !allArgs.includes('--no-tty');
-    let forwarded = stripRoutingFlags(allArgs, STRIP_SPECS);
-    if (!interactive && spec.nonInteractive)
-        forwarded = [...forwarded, ...spec.nonInteractive];
+    const forwarded = buildPassthroughForwardedArgs(command, allArgs, interactive);
     // The one long-running case: keep the remote team supervisor alive past a
     // disconnect by dispatching it detached (nohup), still streaming live.
     const isWatchedTeamStart = command === 'teams' && forwarded[1] === 'start' && forwarded.includes('--watch');

package/dist/lib/hosts/session-index.js

@@ -21,7 +21,7 @@ import { upsertSession } from '../session/db.js';
 import { isSessionTrackedAgent } from '../session/types.js';
 import { localLogPath, updateTask } from './tasks.js';
 import { parseSessionIdMarker } from './session-marker.js';
-import { deriveShortId } from '../session/short-id.js';
+import { deriveShortId } from '../text/short-id.js';
 import { normalizeHost } from '../machine-id.js';
 /**
  * Build the SessionMeta for a host-dispatched run. Returns null when the run has

package/dist/lib/import.js

@@ -22,7 +22,7 @@ import * as path from 'path';
 import { AGENTS, resolveNativeBinaryPath } from './agents.js';
 import { getUserAgentsDir, getVersionsDir } from './state.js';
 import { setGlobalDefault } from './installations/versions.js';
-import { createShim, createVersionedAlias, ensureShimCurrent, switchHomeFileSymlinks, assertIsolationBoundary } from './shims.js';
+import { createShim, createVersionedAlias, ensureShimCurrent, switchHomeFileSymlinks, assertIsolationBoundary } from './installations/shims.js';
 const IMPORT_VERSION_RE = /^(?:latest|[A-Za-z0-9._+-]{1,64})$/;
 export function isValidImportVersion(version) {
     return IMPORT_VERSION_RE.test(version);

package/dist/lib/installations/index.d.ts

@@ -7,8 +7,8 @@
  * it, so the internal split can change without breaking callers (the Cursor
  * per-installation isolation track consumes exactly this).
  */
-export { INSTALLATION_RECORD_FILE, INSTALLATION_SCHEMA, type Installation, type InstallationRelease, type UpdateOutcome, type UpdateStrategyId, } from './types.js';
-export { createInstallation, ensureInstallation, installationDir, installationRecordPath, listInstallationLabels, listInstallations, mintInstallationId, readInstallation, recordRelease, writeInstallation, } from './store.js';
-export { InstallationAmbiguousError, InstallationNotFoundError, describeInstallation, resolveInstallation, type ResolveInstallationOptions, } from './resolve.js';
-export { assertValidRelease, selectUpdateStrategy, supportsPinnedUpdate, type UpdateStrategy, } from './strategies.js';
+export { type Installation, type InstallationRelease, type UpdateOutcome, type UpdateStrategyId, } from './types.js';
+export { createInstallation, listInstallations, recordRelease, } from './store.js';
+export { describeInstallation, resolveInstallation, type ResolveInstallationOptions, } from './resolve.js';
+export { selectUpdateStrategy, supportsPinnedUpdate, type UpdateStrategy, } from './strategies.js';
 export { updateInstallation, type UpdateInstallationOptions } from './update.js';

package/dist/lib/installations/index.js

@@ -7,8 +7,7 @@
  * it, so the internal split can change without breaking callers (the Cursor
  * per-installation isolation track consumes exactly this).
  */
-export { INSTALLATION_RECORD_FILE, INSTALLATION_SCHEMA, } from './types.js';
-export { createInstallation, ensureInstallation, installationDir, installationRecordPath, listInstallationLabels, listInstallations, mintInstallationId, readInstallation, recordRelease, writeInstallation, } from './store.js';
-export { InstallationAmbiguousError, InstallationNotFoundError, describeInstallation, resolveInstallation, } from './resolve.js';
-export { assertValidRelease, selectUpdateStrategy, supportsPinnedUpdate, } from './strategies.js';
+export { createInstallation, listInstallations, recordRelease, } from './store.js';
+export { describeInstallation, resolveInstallation, } from './resolve.js';
+export { selectUpdateStrategy, supportsPinnedUpdate, } from './strategies.js';
 export { updateInstallation } from './update.js';

package/dist/lib/installations/migrate.js

@@ -23,7 +23,7 @@ import { evaluateActivationReadiness } from '../routine-readiness.js';
 import { migrateDeviceConfigStores } from '../devices/config-migration.js';
 // Two constants only, never the read/write API — migrations still operate on raw
 // YAML so they never take the meta lock or prime the meta cache mid-migration.
-import { DEFAULT_BROWSER_PROFILE_NAME } from '../browser/profiles.js';
+import { LEGACY_DEFAULT_BROWSER_PROFILE_NAME } from '../browser/profiles.js';
 import { META_HEADER as DEVICE_META_HEADER } from '../state.js';
 import { COMPILED_HEADER_PROJECT } from '../rules/compile.js';
 const HOME = process.env.HOME ?? os.homedir();
@@ -1763,7 +1763,7 @@ export function migrateMachineLocalBrowserProfileOutOfCentral(userDir = USER_DIR
     const browser = central.browser;
     if (!browser || typeof browser !== 'object' || Array.isArray(browser))
         return;
-    const entry = browser[DEFAULT_BROWSER_PROFILE_NAME];
+    const entry = browser[LEGACY_DEFAULT_BROWSER_PROFILE_NAME];
     if (entry === undefined)
         return;
     // Device file first — a crash before central is rewritten leaves a harmless
@@ -1777,15 +1777,15 @@ export function migrateMachineLocalBrowserProfileOutOfCentral(userDir = USER_DIR
     const deviceBrowser = (deviceDoc.browser && typeof deviceDoc.browser === 'object' && !Array.isArray(deviceDoc.browser))
         ? deviceDoc.browser
         : {};
-    if (deviceBrowser[DEFAULT_BROWSER_PROFILE_NAME] === undefined) {
-        deviceBrowser[DEFAULT_BROWSER_PROFILE_NAME] = entry;
+    if (deviceBrowser[LEGACY_DEFAULT_BROWSER_PROFILE_NAME] === undefined) {
+        deviceBrowser[LEGACY_DEFAULT_BROWSER_PROFILE_NAME] = entry;
         deviceDoc.browser = deviceBrowser;
         fs.mkdirSync(path.dirname(devicePath), { recursive: true });
         atomicWriteFileSync(devicePath, DEVICE_META_HEADER + yaml.stringify(deviceDoc));
     }
     // Then strip it from the synced file, dropping `browser:` entirely when the
     // machine-local entry was its only member.
-    doc.deleteIn(['browser', DEFAULT_BROWSER_PROFILE_NAME]);
+    doc.deleteIn(['browser', LEGACY_DEFAULT_BROWSER_PROFILE_NAME]);
     if (Object.keys(browser).length === 1) {
         const itemsOf = () => (doc.contents?.items) ?? [];
         const idx = itemsOf().findIndex((pair) => pair.key?.value === 'browser');
@@ -1806,7 +1806,7 @@ export function migrateMachineLocalBrowserProfileOutOfCentral(userDir = USER_DIR
     // the identical case (state.ts, `isEmpty ? META_HEADER : stringifyDoc(doc)`).
     const remaining = Object.keys(doc.toJSON() ?? {}).length;
     atomicWriteFileSync(metaFile, remaining === 0 ? DEVICE_META_HEADER : stringifyDoc(doc));
-    console.error(`Migrated agents.yaml: browser '${DEFAULT_BROWSER_PROFILE_NAME}' profile -> devices/${machine}/agents.yaml`);
+    console.error(`Migrated agents.yaml: browser '${LEGACY_DEFAULT_BROWSER_PROFILE_NAME}' profile -> devices/${machine}/agents.yaml`);
 }
 /**
  * Rename the legacy `extras-extras/` plugin-marketplace dir to `agents-extras/`

package/dist/lib/{shims.d.ts → installations/shims.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentId } from './types.js';
-import { getShimsDir } from './state.js';
+import type { AgentId } from '../types.js';
+import { getShimsDir } from '../state.js';
 export { getShimsDir };
 /**
  * Strategy for handling file conflicts during config migration.