@phnx-labs/agents-cli 1.14.1 → 1.14.3

package/dist/lib/{memory-compile.js → rules/compile.js}

@@ -1,16 +1,18 @@
 /**
  * Rules file compilation -- resolving @-imports into a single flat file.
  *
- * Agents that do not natively resolve `@path/to/file` imports (Codex, Gemini)
+ * Agents that do not natively resolve `@path/to/file` imports (Codex, Cursor)
  * need a pre-compiled rules file with all imports inlined. This module
- * handles that expansion.
+ * handles that expansion for both user-scope (writes into version home) and
+ * project-scope (writes into the workspace).
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as crypto from 'crypto';
-import { AGENTS } from './agents.js';
-import { getResolvedRulesDir, getVersionsDir } from './state.js';
+import { AGENTS } from '../agents.js';
+import { getResolvedRulesDir, getVersionsDir } from '../state.js';
+import { composeRules, composeRulesFromState } from './compose.js';
 // Match `@path` preceded by start-of-string or whitespace. This avoids
 // matching emails ("foo@bar.com") and the middle of words. The leading
 // whitespace (if any) is captured so we can preserve it in the output.
@@ -18,6 +20,8 @@ const IMPORT_RE = /(^|\s)@(\S+)/g;
 const MAX_DEPTH = 5;
 const COMPILED_HEADER = '<!-- Auto-compiled by agents-cli from ~/.agents/rules/AGENTS.md + imports.\n' +
     '     Edit the source files under ~/.agents/rules/ — edits to this file will be overwritten on next sync. -->\n\n';
+const COMPILED_HEADER_PROJECT = '<!-- Auto-compiled by agents-cli from .agents/rules/AGENTS.md + imports.\n' +
+    '     Edit the source files under .agents/rules/ — edits to this file will be overwritten on next sync. -->\n\n';
 function expandTilde(p) {
     if (p === '~')
         return os.homedir();
@@ -87,10 +91,10 @@ export function resolveImports(content, baseDir) {
     return { content: result, sources };
 }
 /** True if the agent's native runtime resolves `@path` imports in its rules file. */
-export function supportsMemoryImports(agentId) {
-    return !!AGENTS[agentId].capabilities.memoryImports;
+export function supportsRulesImports(agentId) {
+    return !!AGENTS[agentId].capabilities.rulesImports;
 }
-function getCompiledMemoryPath(agentId, version) {
+function getCompiledRulesPath(agentId, version) {
     const agentConfig = AGENTS[agentId];
     const versionHome = path.join(getVersionsDir(), agentId, version, 'home');
     return path.join(versionHome, `.${agentId}`, agentConfig.instructionsFile);
@@ -107,10 +111,10 @@ function getManifestPath(compiledPath) {
  * For agents that support @-imports natively, always returns false — there's
  * nothing to compile.
  */
-export function isMemoryStale(agentId, version) {
-    if (supportsMemoryImports(agentId))
+export function isRulesStale(agentId, version) {
+    if (supportsRulesImports(agentId))
         return false;
-    const compiledPath = getCompiledMemoryPath(agentId, version);
+    const compiledPath = getCompiledRulesPath(agentId, version);
     const manifestPath = getManifestPath(compiledPath);
     if (!fs.existsSync(compiledPath) || !fs.existsSync(manifestPath))
         return true;
@@ -143,19 +147,19 @@ export function isMemoryStale(agentId, version) {
  * Agents that natively resolve @-imports are skipped (no-op) — their sync
  * uses the standard copyFileSync path in `syncResourcesToVersion`.
  */
-export function compileMemoryForAgent(agentId, version) {
-    if (supportsMemoryImports(agentId)) {
+export function compileRulesForAgent(agentId, version) {
+    if (supportsRulesImports(agentId)) {
         return { compiled: false, compiledPath: '', sources: 0 };
     }
-    const memoryDir = getResolvedRulesDir();
-    const sourceAgents = path.join(memoryDir, 'AGENTS.md');
+    const rulesDir = getResolvedRulesDir();
+    const sourceAgents = path.join(rulesDir, 'AGENTS.md');
     if (!fs.existsSync(sourceAgents)) {
         return { compiled: false, compiledPath: '', sources: 0 };
     }
     const rootContent = fs.readFileSync(sourceAgents, 'utf8');
-    const { content, sources } = resolveImports(rootContent, memoryDir);
+    const { content, sources } = resolveImports(rootContent, rulesDir);
     const newContent = COMPILED_HEADER + content;
-    const compiledPath = getCompiledMemoryPath(agentId, version);
+    const compiledPath = getCompiledRulesPath(agentId, version);
     fs.mkdirSync(path.dirname(compiledPath), { recursive: true });
     const existing = fs.existsSync(compiledPath) ? fs.readFileSync(compiledPath, 'utf8') : null;
     if (existing === newContent) {
@@ -175,15 +179,150 @@ export function compileMemoryForAgent(agentId, version) {
     return { compiled: true, compiledPath, sources: allSources.length };
 }
 /**
- * Recompile memory if stale. Safe to call on every agent invocation — the
+ * Recompile rules if stale. Safe to call on every agent invocation — the
  * staleness check is fast (sha256 of 8-10 small files, ~10-20ms). Returns
  * true if a recompile happened, false otherwise.
  */
-export function ensureMemoryFresh(agentId, version) {
-    if (supportsMemoryImports(agentId))
+export function ensureRulesFresh(agentId, version) {
+    if (supportsRulesImports(agentId))
         return false;
-    if (!isMemoryStale(agentId, version))
+    if (!isRulesStale(agentId, version))
         return false;
-    const result = compileMemoryForAgent(agentId, version);
+    const result = compileRulesForAgent(agentId, version);
     return result.compiled;
 }
+/**
+ * Compile project-scope rules into a workspace's root memory files so each
+ * agent's native loader picks them up.
+ *
+ * Composes rules from all available layers (project > user > extras > system)
+ * with project highest priority — so a project's `subrules/` and `rules.yaml`
+ * shadow user/system fragments and presets. Writes `cwd/AGENTS.md` with
+ * COMPILED_HEADER_PROJECT and creates symlinks (CLAUDE.md, GEMINI.md,
+ * .cursorrules, etc.) → AGENTS.md so every agent finds its expected file at
+ * cwd. The agent's own loader merges this project-level file with its
+ * user-level rules (in version home) at runtime.
+ *
+ * Don't-clobber guard: if `cwd/AGENTS.md` exists without our header, the user
+ * authored it — leave it alone and report via `skippedClobber`. Same for any
+ * pre-existing per-agent file or symlink that doesn't already point at
+ * AGENTS.md.
+ *
+ * No-op when `cwd/.agents/rules/` does not exist. Idempotent on repeated
+ * calls — content equality short-circuits the write.
+ */
+export function compileRulesForProject(cwd, opts = {}) {
+    const projectRulesDir = path.join(cwd, '.agents', 'rules');
+    const empty = {
+        compiled: false, agentsPath: '', symlinks: [], sources: 0, skippedClobber: [],
+    };
+    if (!fs.existsSync(projectRulesDir))
+        return empty;
+    let composed;
+    try {
+        // Tests inject `layers` to isolate from real ~/.agents-system / ~/.agents
+        // state. Production callers omit it and compose from discovered state.
+        const result = opts.layers
+            ? composeRules({ preset: opts.preset, layers: opts.layers })
+            : composeRulesFromState({ cwd, preset: opts.preset });
+        composed = { content: result.content, subrules: result.subrules };
+    }
+    catch {
+        // Composer threw (no preset, malformed yaml). Don't write a half-baked
+        // file — bail out cleanly, same as if the rules dir didn't exist.
+        return empty;
+    }
+    const newContent = COMPILED_HEADER_PROJECT + composed.content;
+    const agentsPath = path.join(cwd, 'AGENTS.md');
+    const skippedClobber = [];
+    let compiled = false;
+    let weOwnAgentsMd = false;
+    let agentsLstat = null;
+    try {
+        agentsLstat = fs.lstatSync(agentsPath);
+    }
+    catch { /* missing */ }
+    if (!agentsLstat) {
+        fs.writeFileSync(agentsPath, newContent);
+        compiled = true;
+        weOwnAgentsMd = true;
+    }
+    else if (agentsLstat.isFile()) {
+        let existing = '';
+        try {
+            existing = fs.readFileSync(agentsPath, 'utf8');
+        }
+        catch { /* unreadable */ }
+        if (existing.startsWith(COMPILED_HEADER_PROJECT)) {
+            if (existing !== newContent) {
+                fs.writeFileSync(agentsPath, newContent);
+                compiled = true;
+            }
+            weOwnAgentsMd = true;
+        }
+        else {
+            skippedClobber.push('AGENTS.md');
+        }
+    }
+    else {
+        // Symlink or other non-regular file — treat as user-owned, do not clobber
+        skippedClobber.push('AGENTS.md');
+    }
+    // Per-agent symlinks. Only attempt when we own AGENTS.md — never create a
+    // dangling symlink to a file we couldn't write.
+    const symlinks = [];
+    if (weOwnAgentsMd) {
+        const seen = new Set(['AGENTS.md']);
+        for (const agent of Object.values(AGENTS)) {
+            const fname = agent.instructionsFile;
+            if (seen.has(fname))
+                continue;
+            // Skip agents whose instructions live at a nested path (e.g. OpenClaw's
+            // workspace/AGENTS.md) — those are managed by their own setup paths.
+            if (fname.includes('/') || fname.includes('\\'))
+                continue;
+            seen.add(fname);
+            const linkPath = path.join(cwd, fname);
+            let lstat = null;
+            try {
+                lstat = fs.lstatSync(linkPath);
+            }
+            catch { /* missing */ }
+            if (lstat) {
+                if (lstat.isSymbolicLink()) {
+                    let target = '';
+                    try {
+                        target = fs.readlinkSync(linkPath);
+                    }
+                    catch { /* unreadable */ }
+                    if (target === 'AGENTS.md') {
+                        symlinks.push(fname);
+                        continue;
+                    }
+                    skippedClobber.push(fname);
+                    continue;
+                }
+                // Regular file — user authored
+                skippedClobber.push(fname);
+                continue;
+            }
+            try {
+                fs.symlinkSync('AGENTS.md', linkPath);
+                symlinks.push(fname);
+            }
+            catch {
+                // Filesystems that disallow symlinks (some Windows configs) — fall
+                // back to a copy. The agent reads the same content either way.
+                try {
+                    fs.copyFileSync(agentsPath, linkPath);
+                    symlinks.push(fname);
+                }
+                catch {
+                    // Give up on this one quietly; the agent that needs this filename
+                    // will fall back to its own discovery rules.
+                }
+            }
+        }
+    }
+    return { compiled, agentsPath, symlinks, sources: composed.subrules.length, skippedClobber };
+}

package/dist/lib/rules/compose.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Rules composition — assemble a fully-inlined rules document from layered
+ * `subrules/` fragments and `rules.yaml` preset definitions.
+ *
+ * The model:
+ *   - Every DotAgents repo holds `<repo>/rules/subrules/*.md` (rule fragments)
+ *     and `<repo>/rules/rules.yaml` (preset definitions).
+ *   - Layers are read in precedence order (highest first):
+ *       project > user > extra > system.
+ *   - The active preset's `subrules:` list is resolved against the layer set
+ *     using per-name shadowing — a project subrule shadows a user/system one
+ *     of the same name.
+ *   - Subrules in the user / extra / project layers that the preset did NOT
+ *     name are auto-appended in precedence order. (System auto-append is
+ *     opt-in only: system never auto-appends to avoid noise.)
+ *   - Output is a single concatenated string with no `@-import` syntax.
+ *
+ * No filesystem writes happen here — callers (`syncResourcesToVersion`,
+ * project-rules compile) decide where to land the composed output.
+ */
+export type LayerScope = 'project' | 'user' | 'extra' | 'system';
+export interface RulesLayer {
+    scope: LayerScope;
+    rulesDir: string;
+    /** Set when scope is 'extra'; undefined otherwise. */
+    alias?: string;
+}
+export interface PresetDef {
+    /** Subrule names (without `.md`), in concatenation order. */
+    subrules: string[];
+}
+export interface RulesYaml {
+    presets?: Record<string, PresetDef>;
+}
+export interface ComposeOptions {
+    /** Defaults to `"default"`. */
+    preset?: string;
+    /** Layers in precedence order, highest first. */
+    layers: RulesLayer[];
+}
+export interface ComposedSubrule {
+    name: string;
+    sourcePath: string;
+    layerScope: LayerScope;
+    layerAlias?: string;
+}
+export interface ComposeResult {
+    /** Fully concatenated, no @-imports. */
+    content: string;
+    /** The preset name that was applied. */
+    preset: string;
+    /** The layer that defined the preset. */
+    presetLayer: LayerScope;
+    /** Subrules included, in concatenation order. */
+    subrules: ComposedSubrule[];
+}
+/**
+ * Compose a rules document from the given layers.
+ *
+ * Throws when the requested preset isn't defined in any layer's rules.yaml —
+ * means the caller passed a typo or no layer ships the named preset.
+ */
+export declare function composeRules(opts: ComposeOptions): ComposeResult;
+/**
+ * Discover layers for use at sync time (no cwd) or runtime (with cwd).
+ *
+ * Project layer is included only when cwd is given AND `<cwd>/.agents/rules/`
+ * exists. Without cwd, only user / extras / system are surfaced — matching
+ * the home-file write at sync time.
+ */
+export declare function discoverRulesLayers(opts?: {
+    cwd?: string;
+}): RulesLayer[];
+/** Convenience wrapper — discovers layers from state, then composes. */
+export declare function composeRulesFromState(opts?: {
+    preset?: string;
+    cwd?: string;
+}): ComposeResult;

package/dist/lib/rules/compose.js

@@ -0,0 +1,170 @@
+/**
+ * Rules composition — assemble a fully-inlined rules document from layered
+ * `subrules/` fragments and `rules.yaml` preset definitions.
+ *
+ * The model:
+ *   - Every DotAgents repo holds `<repo>/rules/subrules/*.md` (rule fragments)
+ *     and `<repo>/rules/rules.yaml` (preset definitions).
+ *   - Layers are read in precedence order (highest first):
+ *       project > user > extra > system.
+ *   - The active preset's `subrules:` list is resolved against the layer set
+ *     using per-name shadowing — a project subrule shadows a user/system one
+ *     of the same name.
+ *   - Subrules in the user / extra / project layers that the preset did NOT
+ *     name are auto-appended in precedence order. (System auto-append is
+ *     opt-in only: system never auto-appends to avoid noise.)
+ *   - Output is a single concatenated string with no `@-import` syntax.
+ *
+ * No filesystem writes happen here — callers (`syncResourcesToVersion`,
+ * project-rules compile) decide where to land the composed output.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { getResolvedRulesDir, getUserRulesDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
+const SUBRULES_DIR_NAME = 'subrules';
+const RULES_YAML_NAME = 'rules.yaml';
+const DEFAULT_PRESET = 'default';
+const SUBRULES_README = 'README.md';
+function readRulesYaml(rulesDir) {
+    const p = path.join(rulesDir, RULES_YAML_NAME);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const parsed = yaml.parse(fs.readFileSync(p, 'utf-8'));
+        return parsed || {};
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePreset(layers, preset) {
+    for (const layer of layers) {
+        const yml = readRulesYaml(layer.rulesDir);
+        if (!yml?.presets)
+            continue;
+        const def = yml.presets[preset];
+        if (def)
+            return { def, layer };
+    }
+    return null;
+}
+function findSubrule(layers, name) {
+    for (const layer of layers) {
+        const p = path.join(layer.rulesDir, SUBRULES_DIR_NAME, `${name}.md`);
+        if (fs.existsSync(p))
+            return { sourcePath: p, layer };
+    }
+    return null;
+}
+function listLayerSubruleNames(layer) {
+    const dir = path.join(layer.rulesDir, SUBRULES_DIR_NAME);
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs
+            .readdirSync(dir)
+            .filter((f) => f.endsWith('.md') && f !== SUBRULES_README)
+            .map((f) => f.slice(0, -3))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Compose a rules document from the given layers.
+ *
+ * Throws when the requested preset isn't defined in any layer's rules.yaml —
+ * means the caller passed a typo or no layer ships the named preset.
+ */
+export function composeRules(opts) {
+    const presetName = opts.preset || DEFAULT_PRESET;
+    const presetMatch = resolvePreset(opts.layers, presetName);
+    if (!presetMatch) {
+        throw new Error(`Preset "${presetName}" not found in any rules.yaml across the active layers.`);
+    }
+    const composed = [];
+    const seen = new Set();
+    // 1. Preset's named subrules, resolved by per-name shadowing.
+    for (const name of presetMatch.def.subrules || []) {
+        if (seen.has(name))
+            continue;
+        const found = findSubrule(opts.layers, name);
+        if (!found)
+            continue; // missing subrule: skip silently — same as @-import miss
+        composed.push({
+            name,
+            sourcePath: found.sourcePath,
+            layerScope: found.layer.scope,
+            layerAlias: found.layer.alias,
+        });
+        seen.add(name);
+    }
+    // 2. Auto-append: any subrule in a non-system layer not yet included.
+    //    Honors precedence — project layer's auto-appends come first.
+    for (const layer of opts.layers) {
+        if (layer.scope === 'system')
+            continue;
+        for (const name of listLayerSubruleNames(layer)) {
+            if (seen.has(name))
+                continue;
+            composed.push({
+                name,
+                sourcePath: path.join(layer.rulesDir, SUBRULES_DIR_NAME, `${name}.md`),
+                layerScope: layer.scope,
+                layerAlias: layer.alias,
+            });
+            seen.add(name);
+        }
+    }
+    // 3. Concatenate. Trim trailing whitespace on each fragment so spacing is
+    //    predictable — fragments often end in a newline already.
+    const parts = composed.map((c) => fs.readFileSync(c.sourcePath, 'utf-8').replace(/\s+$/, ''));
+    const content = parts.length === 0 ? '' : parts.join('\n\n') + '\n';
+    return {
+        content,
+        preset: presetName,
+        presetLayer: presetMatch.layer.scope,
+        subrules: composed,
+    };
+}
+/**
+ * Discover layers for use at sync time (no cwd) or runtime (with cwd).
+ *
+ * Project layer is included only when cwd is given AND `<cwd>/.agents/rules/`
+ * exists. Without cwd, only user / extras / system are surfaced — matching
+ * the home-file write at sync time.
+ */
+export function discoverRulesLayers(opts = {}) {
+    const layers = [];
+    if (opts.cwd) {
+        const projectAgentsDir = getProjectAgentsDir(opts.cwd);
+        if (projectAgentsDir) {
+            const rulesDir = path.join(projectAgentsDir, 'rules');
+            if (fs.existsSync(rulesDir)) {
+                layers.push({ scope: 'project', rulesDir });
+            }
+        }
+    }
+    const userRulesDir = getUserRulesDir();
+    if (fs.existsSync(userRulesDir)) {
+        layers.push({ scope: 'user', rulesDir: userRulesDir });
+    }
+    for (const extra of getEnabledExtraRepos()) {
+        const rulesDir = path.join(extra.dir, 'rules');
+        if (fs.existsSync(rulesDir)) {
+            layers.push({ scope: 'extra', rulesDir, alias: extra.alias });
+        }
+    }
+    const systemRulesDir = getResolvedRulesDir();
+    if (fs.existsSync(systemRulesDir)) {
+        layers.push({ scope: 'system', rulesDir: systemRulesDir });
+    }
+    return layers;
+}
+/** Convenience wrapper — discovers layers from state, then composes. */
+export function composeRulesFromState(opts = {}) {
+    const layers = discoverRulesLayers({ cwd: opts.cwd });
+    return composeRules({ preset: opts.preset, layers });
+}

package/dist/lib/{memory.d.ts → rules/rules.d.ts}

@@ -6,7 +6,7 @@
  * GEMINI.md, etc.). This module handles reading, managing includes, and
  * refreshing rules files across version homes.
  */
-import type { AgentId } from './types.js';
+import type { AgentId } from '../types.js';
 export type InstructionsScope = 'user' | 'project';
 export interface InstalledInstructions {
     agentId: AgentId;
@@ -23,7 +23,7 @@ export interface DiscoveredInstructions {
  * Central rules filename constant.
  * All agents map to this file in ~/.agents/rules/, renamed per-agent when synced.
  */
-export declare const CENTRAL_MEMORY_FILENAME = "AGENTS.md";
+export declare const CENTRAL_RULES_FILENAME = "AGENTS.md";
 /**
  * Get the canonical central rules filename for an agent's instructionsFile.
  * Central storage uses AGENTS.md, which gets renamed per-agent when syncing:
@@ -32,12 +32,12 @@ export declare const CENTRAL_MEMORY_FILENAME = "AGENTS.md";
  *   - Cursor: AGENTS.md → .cursorrules
  *   - Codex/OpenCode: AGENTS.md → AGENTS.md (no rename)
  */
-export declare function getCentralMemoryFileName(agentId: AgentId): string;
+export declare function getCentralRulesFileName(agentId: AgentId): string;
 export declare function getInstructionsPath(agentId: AgentId, scope: InstructionsScope, cwd?: string): string;
 export declare function instructionsExists(agentId: AgentId, scope?: InstructionsScope, cwd?: string): boolean;
 export declare function discoverInstructionsFromRepo(repoPath: string): DiscoveredInstructions[];
 export declare function resolveInstructionsSource(repoPath: string, agentId: AgentId): string | null;
-export declare function discoverMemoryFilesFromRepo(repoPath: string): string[];
+export declare function discoverRuleFilesFromRepo(repoPath: string): string[];
 export declare function installInstructions(sourcePath: string, agentId: AgentId, method?: 'symlink' | 'copy'): {
     path: string;
     method: 'symlink' | 'copy';
@@ -60,4 +60,4 @@ export declare function installInstructionsCentrally(repoPath: string, filesToIn
 /**
  * List top-level rules files from user and system dirs (user wins on collision).
  */
-export declare function listCentralMemory(): string[];
+export declare function listCentralRules(): string[];

package/dist/lib/{memory.js → rules/rules.js}

@@ -8,14 +8,14 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { AGENTS, ALL_AGENT_IDS } from './agents.js';
-import { getResolvedRulesDir, getUserRulesDir, getProjectAgentsDir } from './state.js';
-import { getEffectiveHome } from './versions.js';
+import { AGENTS, ALL_AGENT_IDS } from '../agents.js';
+import { getResolvedRulesDir, getUserRulesDir, getProjectAgentsDir } from '../state.js';
+import { getEffectiveHome } from '../versions.js';
 /**
  * Central rules filename constant.
  * All agents map to this file in ~/.agents/rules/, renamed per-agent when synced.
  */
-export const CENTRAL_MEMORY_FILENAME = 'AGENTS.md';
+export const CENTRAL_RULES_FILENAME = 'AGENTS.md';
 const RULES_DOC_FILENAME = 'README.md';
 function isSyncableRuleMarkdown(filename) {
     return filename.endsWith('.md') && filename !== RULES_DOC_FILENAME;
@@ -46,14 +46,14 @@ function listRuleMarkdownFiles(rulesDir) {
  *   - Cursor: AGENTS.md → .cursorrules
  *   - Codex/OpenCode: AGENTS.md → AGENTS.md (no rename)
  */
-export function getCentralMemoryFileName(agentId) {
+export function getCentralRulesFileName(agentId) {
     const agent = AGENTS[agentId];
     const instrFile = agent.instructionsFile;
     // If it contains a path separator, extract just the filename
     const filename = instrFile.includes('/') ? path.basename(instrFile) : instrFile;
     // If the agent's instructionsFile isn't AGENTS.md, it was renamed FROM AGENTS.md
-    if (filename !== CENTRAL_MEMORY_FILENAME) {
-        return CENTRAL_MEMORY_FILENAME;
+    if (filename !== CENTRAL_RULES_FILENAME) {
+        return CENTRAL_RULES_FILENAME;
     }
     return filename;
 }
@@ -75,7 +75,7 @@ export function getInstructionsPath(agentId, scope, cwd = process.cwd()) {
     const projectAgentsDir = getProjectAgentsDir(cwd);
     if (projectAgentsDir) {
         const projectRulesDir = path.join(projectAgentsDir, 'rules');
-        const centralName = getCentralMemoryFileName(agentId);
+        const centralName = getCentralRulesFileName(agentId);
         const candidates = [
             path.join(projectRulesDir, centralName),
             path.join(projectRulesDir, agent.instructionsFile),
@@ -142,7 +142,7 @@ export function resolveInstructionsSource(repoPath, agentId) {
     }
     return null;
 }
-export function discoverMemoryFilesFromRepo(repoPath) {
+export function discoverRuleFilesFromRepo(repoPath) {
     const rulesDir = path.join(repoPath, 'rules');
     if (!fs.existsSync(rulesDir)) {
         return [];
@@ -283,7 +283,7 @@ export function installInstructionsCentrally(repoPath, filesToInstall) {
 /**
  * List top-level rules files from user and system dirs (user wins on collision).
  */
-export function listCentralMemory() {
+export function listCentralRules() {
     const seen = new Set();
     for (const dir of [getUserRulesDir(), getResolvedRulesDir()]) {
         if (!fs.existsSync(dir))