@phnx-labs/agents-cli 1.14.1 → 1.14.3

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

@@ -8,7 +8,7 @@
 /** Unique identifier for a supported AI coding agent. */
 export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'roo';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
-export type RunStrategy = 'pinned' | 'available' | 'rotate';
+export type RunStrategy = 'pinned' | 'available' | 'balanced';
 /** Preview features that users can opt into via `agents beta`. */
 export type BetaFeatureName = 'drive' | 'factory';
 /** Subset of chalk color names used for agent-specific terminal output. */
@@ -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

@@ -111,6 +111,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 +140,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,7 +23,7 @@ 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';
@@ -34,7 +34,7 @@ import { listInstalledSubagents, transformSubagentForClaude, syncSubagentToOpenc
 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,28 +117,34 @@ 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);
+    result.memory = Array.from(presetNames);
     // MCP servers (*.yaml files)
     const mcpNames = new Set();
     for (const { base } of resourceBases) {
@@ -316,47 +322,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)) {
@@ -886,6 +858,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 +997,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 +1009,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 +1341,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 +1588,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.1",
+  "version": "1.14.3",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -48,6 +48,35 @@ function runMigrations() {
       fs.unlinkSync(configSrc);
     } catch { /* best-effort */ }
   }
+
+  // 4. Move installed agent versions from ~/.agents/versions/ -> ~/.agents-system/versions/
+  // Pre-split layout put binaries under the user repo. Post-split, listInstalledVersions
+  // only scans the system root, so legacy installs become invisible without this move.
+  const userVersions = path.join(USER_DIR, 'versions');
+  const sysVersions = path.join(SYSTEM_DIR, 'versions');
+  if (fs.existsSync(userVersions)) {
+    try {
+      let moved = 0;
+      let skipped = 0;
+      for (const agent of fs.readdirSync(userVersions, { withFileTypes: true })) {
+        if (!agent.isDirectory()) continue;
+        const srcAgentDir = path.join(userVersions, agent.name);
+        const dstAgentDir = path.join(sysVersions, agent.name);
+        try { fs.mkdirSync(dstAgentDir, { recursive: true }); } catch {}
+        for (const ver of fs.readdirSync(srcAgentDir, { withFileTypes: true })) {
+          if (!ver.isDirectory()) continue;
+          const src = path.join(srcAgentDir, ver.name);
+          const dst = path.join(dstAgentDir, ver.name);
+          if (fs.existsSync(dst)) { skipped++; continue; }
+          try { fs.renameSync(src, dst); moved++; } catch {}
+        }
+        try { if (fs.readdirSync(srcAgentDir).length === 0) fs.rmdirSync(srcAgentDir); } catch {}
+      }
+      try { if (fs.readdirSync(userVersions).length === 0) fs.rmdirSync(userVersions); } catch {}
+      if (moved > 0) console.log(`  Migrated ${moved} agent version dir(s) to ~/.agents-system/versions/`);
+      if (skipped > 0) console.log(`  Kept ${skipped} legacy version dir(s) at ~/.agents/versions/ (already present in system root)`);
+    } catch { /* best-effort */ }
+  }
 }
 
 runMigrations();

package/dist/commands/refresh-memory.d.ts

@@ -1,15 +0,0 @@
-/**
- * Internal memory refresh command.
- *
- * Registers the hidden `agents refresh-memory` command invoked by
- * shims for agents that do not natively resolve @-imports in their
- * memory file. Recompiles memory only when source files have changed.
- */
-import { Command } from 'commander';
-/**
- * Hidden command invoked by shims for agents that don't natively resolve
- * @-imports in their memory file. Fast-path check first (sha256 of tracked
- * source files); only recompiles if a source has changed since the last
- * sync. Typical cost: 10-20ms when memory is fresh.
- */
-export declare function registerRefreshMemoryCommand(program: Command): void;