@phnx-labs/agents-cli 1.14.2 → 1.14.4

package/dist/lib/teams/worktree.d.ts

@@ -0,0 +1,30 @@
+export declare function isGitRepo(dir: string): Promise<boolean>;
+export declare function getGitRoot(dir: string): Promise<string>;
+/**
+ * Check if a worktree directory has uncommitted changes.
+ */
+export declare function hasUncommittedChanges(worktreePath: string): Promise<boolean>;
+/**
+ * Create a new git worktree for a teammate.
+ *
+ * @param repoDir - Directory inside the git repository
+ * @param worktreeName - Name for the worktree (used in path and branch)
+ * @returns The absolute path to the created worktree
+ */
+export declare function createWorktree(repoDir: string, worktreeName: string): Promise<string>;
+/**
+ * Remove a git worktree and optionally its branch.
+ *
+ * @param repoDir - Directory inside the main git repository (not the worktree)
+ * @param worktreeName - Name of the worktree to remove
+ * @param deleteBranch - Whether to delete the associated branch
+ */
+export declare function removeWorktree(repoDir: string, worktreeName: string, deleteBranch?: boolean): Promise<void>;
+/**
+ * Get the worktree path for a given name.
+ */
+export declare function getWorktreePath(gitRoot: string, worktreeName: string): string;
+/**
+ * Get the branch name for a worktree.
+ */
+export declare function getWorktreeBranch(worktreeName: string): string;

package/dist/lib/teams/worktree.js

@@ -0,0 +1,96 @@
+/**
+ * Git worktree utilities for isolated agent execution.
+ *
+ * Creates/removes temporary worktrees so each teammate can work on
+ * its own branch without interfering with others or the main checkout.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const execFileAsync = promisify(execFile);
+export async function isGitRepo(dir) {
+    try {
+        await execFileAsync('git', ['rev-parse', '--git-dir'], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getGitRoot(dir) {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd: dir });
+    return stdout.trim();
+}
+/**
+ * Check if a worktree directory has uncommitted changes.
+ */
+export async function hasUncommittedChanges(worktreePath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--porcelain'], { cwd: worktreePath });
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a new git worktree for a teammate.
+ *
+ * @param repoDir - Directory inside the git repository
+ * @param worktreeName - Name for the worktree (used in path and branch)
+ * @returns The absolute path to the created worktree
+ */
+export async function createWorktree(repoDir, worktreeName) {
+    const gitRoot = await getGitRoot(repoDir);
+    const worktreePath = path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+    const branchName = `agents/${worktreeName}`;
+    await fs.mkdir(path.dirname(worktreePath), { recursive: true });
+    await execFileAsync('git', ['worktree', 'add', '-b', branchName, worktreePath, 'HEAD'], {
+        cwd: gitRoot,
+    });
+    return worktreePath;
+}
+/**
+ * Remove a git worktree and optionally its branch.
+ *
+ * @param repoDir - Directory inside the main git repository (not the worktree)
+ * @param worktreeName - Name of the worktree to remove
+ * @param deleteBranch - Whether to delete the associated branch
+ */
+export async function removeWorktree(repoDir, worktreeName, deleteBranch = true) {
+    const gitRoot = await getGitRoot(repoDir);
+    const worktreePath = path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+    const branchName = `agents/${worktreeName}`;
+    try {
+        await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: gitRoot });
+    }
+    catch (err) {
+        if (err.message?.includes('is not a working tree')) {
+            await execFileAsync('git', ['worktree', 'prune'], { cwd: gitRoot });
+        }
+        else {
+            throw err;
+        }
+    }
+    if (deleteBranch) {
+        try {
+            await execFileAsync('git', ['branch', '-D', branchName], { cwd: gitRoot });
+        }
+        catch {
+            // Branch might not exist; ignore
+        }
+    }
+}
+/**
+ * Get the worktree path for a given name.
+ */
+export function getWorktreePath(gitRoot, worktreeName) {
+    return path.join(gitRoot, '.agents', 'worktrees', worktreeName);
+}
+/**
+ * Get the branch name for a worktree.
+ */
+export function getWorktreeBranch(worktreeName) {
+    return `agents/${worktreeName}`;
+}

package/dist/lib/types.d.ts

@@ -41,10 +41,10 @@ export interface AgentConfig {
         plugins: Capability;
         /**
          * Whether the agent natively resolves `@path/to/file` imports inside its
-         * memory file at session start. If false, agents-cli must pre-compile the
-         * memory file (inline all @-imports) when syncing it into the version home.
+         * rules file at session start. If false, agents-cli must pre-compile the
+         * rules file (inline all @-imports) when syncing it into the version home.
          */
-        memoryImports?: boolean;
+        rulesImports?: boolean;
     };
 }
 /**
@@ -186,9 +186,9 @@ export interface RepoInfo {
     lastSync: string;
 }
 /** Canonical system repo cloned into ~/.agents-system/. */
-export declare const DEFAULT_SYSTEM_REPO = "gh:phnx-labs/.agents";
-/** Previous system repo (personal fork), kept for migration detection. */
-export declare const LEGACY_SYSTEM_REPO = "gh:muqsitnawaz/.agents";
+export declare const DEFAULT_SYSTEM_REPO = "gh:muqsitnawaz/.agents-system";
+/** Mirror system repo (phnx-labs) — will become the default once fully released. */
+export declare const MIRROR_SYSTEM_REPO = "gh:phnx-labs/.agents-system";
 /** Strip the `gh:` prefix and `.git` suffix to get a GitHub `owner/repo` slug. */
 export declare function systemRepoSlug(repo?: string): string;
 /** Kind of package that can be searched and installed from a registry. */
@@ -299,6 +299,12 @@ export interface VersionResources {
     permissions?: string[];
     subagents?: string[];
     plugins?: string[];
+    /**
+     * Active rule preset for this agent@version. The composer reads layered
+     * `rules.yaml` files and emits this preset's subrules as the agent's
+     * single instruction file. Absent/null means the literal "default" preset.
+     */
+    rulesPreset?: string;
 }
 /** Manifest file (plugin.yaml) at the root of a plugin bundle. */
 export interface PluginManifest {

package/dist/lib/types.js

@@ -6,9 +6,9 @@
  * formats for each supported agent.
  */
 /** Canonical system repo cloned into ~/.agents-system/. */
-export const DEFAULT_SYSTEM_REPO = 'gh:phnx-labs/.agents';
-/** Previous system repo (personal fork), kept for migration detection. */
-export const LEGACY_SYSTEM_REPO = 'gh:muqsitnawaz/.agents';
+export const DEFAULT_SYSTEM_REPO = 'gh:muqsitnawaz/.agents-system';
+/** Mirror system repo (phnx-labs) — will become the default once fully released. */
+export const MIRROR_SYSTEM_REPO = 'gh:phnx-labs/.agents-system';
 /** Strip the `gh:` prefix and `.git` suffix to get a GitHub `owner/repo` slug. */
 export function systemRepoSlug(repo = DEFAULT_SYSTEM_REPO) {
     return repo.replace(/^gh:/, '').replace(/\.git$/, '');

package/dist/lib/versions.d.ts

@@ -54,8 +54,9 @@ export declare function getActuallySyncedResources(agent: AgentId, version: stri
 export declare function getNewResources(available: AvailableResources, actuallySynced: AvailableResources): AvailableResources;
 /**
  * Check if there are any new resources to sync.
+ * When version is provided, uses version-specific capability checks.
  */
-export declare function hasNewResources(diff: AvailableResources, agent?: AgentId): boolean;
+export declare function hasNewResources(diff: AvailableResources, agent?: AgentId, version?: string): boolean;
 /**
  * Prompt user to select which NEW resources to sync.
  * Only shows resources that haven't been synced yet.
@@ -111,6 +112,18 @@ export declare function isLatestInstalled(agent: AgentId): Promise<{
  * List all installed versions for an agent.
  */
 export declare function listInstalledVersions(agent: AgentId): string[];
+/**
+ * List every version directory for an agent, including ones missing the
+ * binary (typically home-only leftovers from a prior `removeVersion`).
+ *
+ * Used by `agents prune` to surface stale installs that the regular
+ * `listInstalledVersions` filters out. Do NOT use elsewhere — every other
+ * call site assumes a working binary.
+ */
+export declare function listInstalledVersionDirs(agent: AgentId): Array<{
+    version: string;
+    hasBinary: boolean;
+}>;
 /**
  * Get the global default version for an agent.
  */
@@ -128,8 +141,24 @@ export declare function installVersion(agent: AgentId, version: string, onProgre
     error?: string;
 }>;
 /**
- * Remove a specific version of an agent. Preserves `home/` under the version
- * directory so conversation history survives reinstalls.
+ * Soft-delete a version directory by moving it to ~/.agents-system/trash/versions/.
+ * Returns the trash path on success or null on failure / no source.
+ *
+ * Trash layout: ~/.agents-system/trash/versions/<agent>/<version>/<timestamp>/
+ * The timestamp suffix lets a user soft-delete the same version twice (after
+ * re-install) without collision and gives a chronological audit trail.
+ *
+ * The whole versionDir moves — including `home/` (transcripts, sessions). The
+ * user can recover everything via `agents trash restore <agent>@<version>`.
+ * Nothing is ever hard-deleted.
+ */
+export declare function softDeleteVersionDir(agent: AgentId, version: string): string | null;
+/**
+ * Remove a specific version of an agent.
+ *
+ * Soft-delete only: moves the entire version directory (including `home/`)
+ * to ~/.agents-system/trash/versions/. Recoverable via `agents trash restore`.
+ * Nothing is hard-deleted.
  */
 export declare function removeVersion(agent: AgentId, version: string): boolean;
 /**

package/dist/lib/versions.js

@@ -23,18 +23,18 @@ import { promisify } from 'util';
 import chalk from 'chalk';
 import * as TOML from 'smol-toml';
 import { checkbox, select } from '@inquirer/prompts';
-import { getVersionsDir, ensureAgentsDir, readMeta, writeMeta, getCommandsDir, getSkillsDir, getHooksDir, getResolvedRulesDir, getUserRulesDir, clearVersionResources, recordVersionResources, getProjectAgentsDir, getPromptcutsPath, getEnabledExtraRepos, getAgentsDir, getUserAgentsDir } from './state.js';
+import { getVersionsDir, ensureAgentsDir, readMeta, writeMeta, getCommandsDir, getSkillsDir, getHooksDir, getResolvedRulesDir, getUserRulesDir, clearVersionResources, recordVersionResources, getProjectAgentsDir, getPromptcutsPath, getEnabledExtraRepos, getAgentsDir, getUserAgentsDir, getTrashVersionsDir, getActiveRulesPreset } from './state.js';
 import { resolveResource } from './resources.js';
 import { AGENTS, getAccountEmail, MCP_CAPABLE_AGENTS, COMMANDS_CAPABLE_AGENTS, getMcpConfigPathForHome, parseMcpConfig, resolveAgentName, formatAgentError } from './agents.js';
 import { applyPermissionsToVersion as applyPermsToVersion, PERMISSIONS_CAPABLE_AGENTS, discoverPermissionGroups, buildPermissionsFromGroups, CODEX_RULES_FILENAME, getActivePermissionSetName, readPermissionSetRecipe, PERMISSION_SET_ENV_VAR } from './permissions.js';
-import { installMcpServers } from './mcp.js';
+import { installMcpServers, parseMcpServerConfig } from './mcp.js';
 import { markdownToToml } from './convert.js';
 import { createVersionedAlias, removeVersionedAlias, getConfigSymlinkVersion, ensureClaudeInsideSymlink } from './shims.js';
 import { listInstalledSubagents, transformSubagentForClaude, syncSubagentToOpenclaw, SUBAGENT_CAPABLE_AGENTS } from './subagents.js';
 import { registerHooksToSettings } from './hooks.js';
 import { supports, explainSkip } from './capabilities.js';
 import { discoverPlugins, syncPluginToVersion, isPluginSynced, pluginSupportsAgent, cleanOrphanedPluginSkills } from './plugins.js';
-import { compileMemoryForAgent } from './memory-compile.js';
+import { composeRulesFromState } from './rules/compose.js';
 import { loadSyncManifest, saveSyncManifest, buildManifest, isSyncStale } from './sync-manifest.js';
 import { PLUGINS_CAPABLE_AGENTS } from './agents.js';
 import { safeJoin } from './paths.js';
@@ -117,39 +117,46 @@ export function getAvailableResources(cwd = process.cwd()) {
         }
     }
     result.hooks = Array.from(hookNames);
-    // Rules (*.md files, excluding symlinks and README)
-    // Scan 'rules/' first (canonical), then 'memory/' (legacy name) for backward compat.
-    const memoryNames = new Set();
-    for (const { base } of resourceBases) {
-        for (const subdir of ['rules', 'memory']) {
-            const memoryDir = path.join(base, subdir);
-            if (!fs.existsSync(memoryDir))
-                continue;
-            const names = fs.readdirSync(memoryDir)
-                .filter(f => {
-                if (!f.endsWith('.md') || f === RULES_DOC_FILENAME)
-                    return false;
-                const stat = fs.lstatSync(path.join(memoryDir, f));
-                return !stat.isSymbolicLink();
-            })
-                .map(f => f.replace(/\.md$/, ''));
-            for (const name of names) {
-                memoryNames.add(name);
+    // Rules — list available presets across layers (project > user > extras > system).
+    // The composer selects exactly one preset per sync; this list drives the
+    // resource-count display and `agents rules switch` picker. Routes through
+    // the rules-dir getters so test mocks work the same as production paths.
+    const presetNames = new Set();
+    const rulesDirs = [];
+    if (projectAgentsDir)
+        rulesDirs.push(path.join(projectAgentsDir, 'rules'));
+    rulesDirs.push(getUserRulesDir());
+    rulesDirs.push(getResolvedRulesDir());
+    for (const extra of getEnabledExtraRepos()) {
+        rulesDirs.push(path.join(extra.dir, 'rules'));
+    }
+    for (const rulesDir of rulesDirs) {
+        const rulesYamlPath = path.join(rulesDir, 'rules.yaml');
+        if (!fs.existsSync(rulesYamlPath))
+            continue;
+        try {
+            const parsed = yaml.parse(fs.readFileSync(rulesYamlPath, 'utf-8'));
+            for (const name of Object.keys(parsed?.presets || {})) {
+                presetNames.add(name);
             }
         }
+        catch {
+            // malformed rules.yaml — skip silently; the composer will surface the error.
+        }
     }
-    result.memory = Array.from(memoryNames);
-    // MCP servers (*.yaml files)
+    result.memory = Array.from(presetNames);
+    // MCP servers (*.yaml files) — use the `name:` field inside, not filename
     const mcpNames = new Set();
     for (const { base } of resourceBases) {
         const mcpDir = path.join(base, 'mcp');
         if (!fs.existsSync(mcpDir))
             continue;
-        const names = fs.readdirSync(mcpDir)
-            .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
-            .map(f => f.replace(/\.(yaml|yml)$/, ''));
-        for (const name of names) {
-            mcpNames.add(name);
+        const files = fs.readdirSync(mcpDir)
+            .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+        for (const file of files) {
+            const config = parseMcpServerConfig(path.join(mcpDir, file));
+            if (config?.name)
+                mcpNames.add(config.name);
         }
     }
     result.mcp = Array.from(mcpNames);
@@ -316,47 +323,13 @@ export function getActuallySyncedResources(agent, version, options = {}) {
             }
         }
     }
-    // Rules - check which instruction files are actually in sync (content matches)
-    const memoryDir = getResolvedRulesDir();
-    const projectMemoryDir = projectAgentsDir ? path.join(projectAgentsDir, 'rules') : null;
-    const userMemoryDir = getUserRulesDir();
-    const memoryFiles = new Set();
-    if (fs.existsSync(memoryDir)) {
-        fs.readdirSync(memoryDir).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME).forEach(f => memoryFiles.add(f));
-    }
-    if (projectMemoryDir && fs.existsSync(projectMemoryDir)) {
-        fs.readdirSync(projectMemoryDir).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME).forEach(f => memoryFiles.add(f));
-    }
-    if (fs.existsSync(userMemoryDir)) {
-        fs.readdirSync(userMemoryDir).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME).forEach(f => memoryFiles.add(f));
-    }
-    for (const file of memoryFiles) {
-        const memName = file.replace(/\.md$/, '');
-        const targetName = file === 'AGENTS.md' ? agentConfig.instructionsFile : file;
-        const versionFile = path.join(configDir, targetName);
-        if (!fs.existsSync(versionFile))
-            continue;
-        const projectFile = projectMemoryDir ? path.join(projectMemoryDir, file) : null;
-        const centralFile = path.join(memoryDir, file);
-        const userFile = path.join(userMemoryDir, file);
-        const hasProject = projectFile ? fs.existsSync(projectFile) : false;
-        const hasUser = fs.existsSync(userFile);
-        const hasCentral = fs.existsSync(centralFile);
-        const sourceFile = hasProject ? projectFile : hasUser ? userFile : centralFile;
-        if (!hasProject && !hasCentral && !hasUser) {
-            result.memory.push(memName);
-            continue;
-        }
-        try {
-            const centralContent = fs.readFileSync(sourceFile, 'utf-8');
-            const versionContent = fs.readFileSync(versionFile, 'utf-8');
-            if (centralContent === versionContent) {
-                result.memory.push(memName);
-            }
-        }
-        catch {
-            // Ignore
-        }
+    // Rules — single composed instruction file per agent. If the file exists in
+    // the version home, we consider the active preset synced. Available presets
+    // are surfaced from rules.yaml; this set is the subset that materialized.
+    const instrFile = path.join(configDir, agentConfig.instructionsFile);
+    if (fs.existsSync(instrFile)) {
+        const activePreset = getActiveRulesPreset(agent, version);
+        result.memory.push(activePreset);
     }
     // MCP - use canonical config path + parser per agent
     if (MCP_CAPABLE_AGENTS.includes(agent)) {
@@ -487,7 +460,11 @@ export function getNewResources(available, actuallySynced) {
         commands: available.commands.filter(c => !actuallySynced.commands.includes(c)),
         skills: available.skills.filter(s => !actuallySynced.skills.includes(s)),
         hooks: available.hooks.filter(h => !actuallySynced.hooks.includes(h)),
-        memory: available.memory.filter(m => !actuallySynced.memory.includes(m)),
+        // Memory/rules presets are mutually exclusive — only one can be active.
+        // If any preset is synced, don't report others as "new".
+        memory: actuallySynced.memory.length > 0
+            ? []
+            : available.memory.filter(m => !actuallySynced.memory.includes(m)),
         mcp: available.mcp.filter(m => !actuallySynced.mcp.includes(m)),
         permissions: available.permissions.filter(p => !actuallySynced.permissions.includes(p)),
         subagents: available.subagents.filter(s => !actuallySynced.subagents.includes(s)),
@@ -499,14 +476,15 @@ export function getNewResources(available, actuallySynced) {
 }
 /**
  * Check if there are any new resources to sync.
+ * When version is provided, uses version-specific capability checks.
  */
-export function hasNewResources(diff, agent) {
-    const commandsApply = agent ? COMMANDS_CAPABLE_AGENTS.includes(agent) : true;
-    const hooksApply = agent ? AGENTS[agent].supportsHooks : true;
-    const mcpApply = agent ? MCP_CAPABLE_AGENTS.includes(agent) : true;
-    const permsApply = agent ? PERMISSIONS_CAPABLE_AGENTS.includes(agent) : true;
+export function hasNewResources(diff, agent, version) {
+    const commandsApply = agent ? supports(agent, 'commands', version).ok : true;
+    const hooksApply = agent ? supports(agent, 'hooks', version).ok : true;
+    const mcpApply = agent ? supports(agent, 'mcp', version).ok : true;
+    const permsApply = agent ? supports(agent, 'allowlist', version).ok : true;
     const subagentsApply = agent ? SUBAGENT_CAPABLE_AGENTS.includes(agent) : true;
-    const pluginsApply = agent ? PLUGINS_CAPABLE_AGENTS.includes(agent) : true;
+    const pluginsApply = agent ? supports(agent, 'plugins', version).ok : true;
     return ((diff.commands.length > 0 && commandsApply) ||
         diff.skills.length > 0 ||
         (diff.hooks.length > 0 && hooksApply) ||
@@ -886,6 +864,31 @@ export function listInstalledVersions(agent) {
     }
     return versions.sort(compareVersions);
 }
+/**
+ * List every version directory for an agent, including ones missing the
+ * binary (typically home-only leftovers from a prior `removeVersion`).
+ *
+ * Used by `agents prune` to surface stale installs that the regular
+ * `listInstalledVersions` filters out. Do NOT use elsewhere — every other
+ * call site assumes a working binary.
+ */
+export function listInstalledVersionDirs(agent) {
+    const agentVersionsDir = path.join(getVersionsDir(), agent);
+    if (!fs.existsSync(agentVersionsDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(agentVersionsDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        out.push({
+            version: entry.name,
+            hasBinary: fs.existsSync(getBinaryPath(agent, entry.name)),
+        });
+    }
+    return out.sort((a, b) => compareVersions(a.version, b.version));
+}
 /**
  * Get the global default version for an agent.
  */
@@ -1000,8 +1003,9 @@ export async function installVersion(agent, version, onProgress) {
 /**
  * Remove install artifacts from a version directory, preserving `home/` which
  * contains the user's conversation history, sessions, history.jsonl, tasks,
- * todos, file-history, etc. Called by removeVersion so that uninstalling a
- * version never deletes the user's transcripts.
+ * todos, file-history, etc. Used by the install pipeline (NOT by removeVersion)
+ * to clean up staging artifacts when a fresh install collides with an existing
+ * dir. removeVersion uses soft-delete instead.
  */
 function removeInstallArtifacts(versionDir) {
     for (const entry of fs.readdirSync(versionDir)) {
@@ -1011,15 +1015,50 @@ function removeInstallArtifacts(versionDir) {
     }
 }
 /**
- * Remove a specific version of an agent. Preserves `home/` under the version
- * directory so conversation history survives reinstalls.
+ * Soft-delete a version directory by moving it to ~/.agents-system/trash/versions/.
+ * Returns the trash path on success or null on failure / no source.
+ *
+ * Trash layout: ~/.agents-system/trash/versions/<agent>/<version>/<timestamp>/
+ * The timestamp suffix lets a user soft-delete the same version twice (after
+ * re-install) without collision and gives a chronological audit trail.
+ *
+ * The whole versionDir moves — including `home/` (transcripts, sessions). The
+ * user can recover everything via `agents trash restore <agent>@<version>`.
+ * Nothing is ever hard-deleted.
+ */
+export function softDeleteVersionDir(agent, version) {
+    const versionDir = getVersionDir(agent, version);
+    if (!fs.existsSync(versionDir))
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const trashRoot = getTrashVersionsDir();
+    const trashAgentDir = path.join(trashRoot, agent, version);
+    const trashDest = path.join(trashAgentDir, stamp);
+    try {
+        fs.mkdirSync(trashAgentDir, { recursive: true, mode: 0o700 });
+        fs.renameSync(versionDir, trashDest);
+        return trashDest;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove a specific version of an agent.
+ *
+ * Soft-delete only: moves the entire version directory (including `home/`)
+ * to ~/.agents-system/trash/versions/. Recoverable via `agents trash restore`.
+ * Nothing is hard-deleted.
  */
 export function removeVersion(agent, version) {
     const versionDir = getVersionDir(agent, version);
     if (!fs.existsSync(versionDir)) {
         return false;
     }
-    removeInstallArtifacts(versionDir);
+    const trashPath = softDeleteVersionDir(agent, version);
+    if (!trashPath) {
+        return false;
+    }
     // Remove versioned alias (e.g., claude@2.0.65)
     removeVersionedAlias(agent, version);
     // Clear resource tracking for this version
@@ -1308,10 +1347,10 @@ export function getResourceDiff(agent, version) {
         }
     }
     // Rules: check individual file symlinks
-    const centralMemory = getResolvedRulesDir();
-    if (fs.existsSync(centralMemory)) {
-        const memoryFiles = fs.readdirSync(centralMemory).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME);
-        for (const file of memoryFiles) {
+    const systemRulesDir = getResolvedRulesDir();
+    if (fs.existsSync(systemRulesDir)) {
+        const ruleFiles = fs.readdirSync(systemRulesDir).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME);
+        for (const file of ruleFiles) {
             const targetName = file === 'AGENTS.md' ? agentConfig.instructionsFile : file;
             const targetPath = path.join(agentDir, targetName);
             const status = getSymlinkStatus(targetPath);
@@ -1555,44 +1594,33 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
             }
         }
     }
-    // Sync memory files
-    const memoryToSync = selection
-        ? resolveSelection(selection.memory, available.memory)
-        : available.memory;
-    if (memoryToSync.length > 0 && COMMANDS_CAPABLE_AGENTS.includes(agent)) {
-        const centralMemory = getResolvedRulesDir();
-        const projectMemoryDir = projectAgentsDir ? path.join(projectAgentsDir, 'rules') : null;
-        const userMemoryDir = getUserRulesDir();
-        const syncedMemory = [];
-        const agentSupportsImports = !!agentConfig.capabilities.memoryImports;
-        for (const mem of memoryToSync) {
-            const candidates = [
-                projectMemoryDir ? safeJoin(projectMemoryDir, `${mem}.md`) : null,
-                safeJoin(userMemoryDir, `${mem}.md`),
-                safeJoin(centralMemory, `${mem}.md`),
-                ...extraRepos.map((e) => safeJoin(path.join(e.dir, 'rules'), `${mem}.md`)),
-            ];
-            const srcFile = candidates.find((p) => p && fs.existsSync(p) && !fs.lstatSync(p).isSymbolicLink()) || null;
-            if (!srcFile)
-                continue;
-            const targetName = mem === 'AGENTS' ? agentConfig.instructionsFile : `${mem}.md`;
+    // Sync rules — compose from layered subrules + active preset and write a
+    // single inlined instruction file. No @-import expansion; no per-fragment
+    // copies. Project rules are NOT synced into the version home — they are
+    // composed into the workspace at agents-run time (see compileRulesForProject).
+    const skipMemory = selection && (selection.memory === undefined || (Array.isArray(selection.memory) && selection.memory.length === 0));
+    if (!skipMemory && COMMANDS_CAPABLE_AGENTS.includes(agent)) {
+        try {
+            // If selection.memory names a single preset, treat it as a one-shot
+            // override; otherwise read the persisted active preset.
+            const overridePreset = Array.isArray(selection?.memory) && selection.memory.length === 1 && selection.memory[0] !== 'AGENTS'
+                ? selection.memory[0]
+                : null;
+            const preset = overridePreset || getActiveRulesPreset(agent, version);
+            const composed = composeRulesFromState({ preset });
+            const targetName = agentConfig.instructionsFile;
             const destFile = safeJoin(agentDir, targetName);
+            fs.mkdirSync(path.dirname(destFile), { recursive: true });
             removePath(destFile);
-            // For the primary memory file (AGENTS.md), agents that don't natively
-            // resolve @-imports get a compiled (inlined) copy + sidecar manifest.
-            // Everything else (secondary memory files, @-capable agents) gets a
-            // straight copy.
-            if (mem === 'AGENTS' && !agentSupportsImports) {
-                compileMemoryForAgent(agent, version);
-            }
-            else {
-                fs.copyFileSync(srcFile, destFile);
-            }
+            fs.writeFileSync(destFile, composed.content);
             result.memory.push(targetName);
-            syncedMemory.push(mem);
+            // Track which preset materialized — surfaces in `agents rules list`.
+            recordVersionResources(agent, version, 'memory', [composed.preset]);
         }
-        if (syncedMemory.length > 0) {
-            recordVersionResources(agent, version, 'memory', syncedMemory);
+        catch (err) {
+            // No rules.yaml yet, or a typo'd preset name. Don't fail the whole sync —
+            // just leave the agent without a synced rules file.
+            console.warn(`Skipping rules sync for ${agent}@${version}: ${err.message}`);
         }
     }
     // Apply permissions (if agent supports them).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.14.2",
+  "version": "1.14.4",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,8 @@
   },
   "bin": {
     "agents": "dist/index.js",
-    "ag": "dist/index.js"
+    "ag": "dist/index.js",
+    "browser": "dist/browser.js"
   },
   "files": [
     "dist/**/*.js",