@technomoron/agent-run 0.99.28 → 0.99.30

package/dist/config/render-settings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderProfileConfig = renderProfileConfig;
+exports.parseJsonObject = parseJsonObject;
+const fs = require("fs");
+const path = require("path");
+const templates_1 = require("../templates");
+const utils_1 = require("../utils");
+function renderProfileConfig(env, configRoot, context, overrideFileName, globalTemplatePath, fallback, label, trace) {
+    const templatePath = resolveProfileOverrideTemplate(configRoot, context, overrideFileName, globalTemplatePath);
+    const content = templatePath
+        ? (0, templates_1.renderTemplateFile)(env, configRoot, templatePath, context, trace)
+        : fallback();
+    (0, templates_1.assertNoUnexpandedTemplateVars)(label, content);
+    return content.replace(/\n*$/, '\n');
+}
+function parseJsonObject(content, label) {
+    try {
+        const parsed = JSON.parse(content);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('top-level value must be an object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`invalid generated ${label} JSON: ${(0, utils_1.formatError)(error)}`);
+    }
+}
+function resolveProfileOverrideTemplate(configRoot, context, overrideFileName, globalTemplatePath) {
+    const overridePath = `${context.profile}/overrides/${overrideFileName}`;
+    if (fs.existsSync(path.join(configRoot, overridePath))) {
+        return overridePath;
+    }
+    return fs.existsSync(path.join(configRoot, globalTemplatePath)) ? globalTemplatePath : null;
+}

package/dist/config/render-skills.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCanonicalSkills = buildCanonicalSkills;
+exports.renderSkillFiles = renderSkillFiles;
+exports.validateRenderedSkill = validateRenderedSkill;
+const fs = require("fs");
+const path = require("path");
+const templates_1 = require("../templates");
+function buildCanonicalSkills(env, configRoot, manifest, context, trace) {
+    return manifest.skills.install.map((name) => {
+        const sourceTemplate = manifest.skills.overrides[name] ?? `global/skills/${name}/SKILL.md.njk`;
+        const sourcePath = (0, templates_1.resolveConfigPath)(configRoot, sourceTemplate, context);
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`missing skill template for ${name}: ${sourcePath}`);
+        }
+        const renderedContent = (0, templates_1.renderTemplateFile)(env, configRoot, sourceTemplate, context, trace);
+        (0, templates_1.assertNoUnexpandedTemplateVars)(`skill ${name}`, renderedContent);
+        validateRenderedSkill(renderedContent, sourcePath);
+        return { name, sourcePath, renderedContent, description: extractSkillDescription(renderedContent) };
+    });
+}
+function renderSkillFiles(context, targetDir) {
+    return context.skills.map((skill) => ({
+        path: path.join(targetDir, skill.name, 'SKILL.md'),
+        content: skill.renderedContent
+    }));
+}
+function validateRenderedSkill(content, sourcePath) {
+    const frontMatter = /^---\n([\s\S]*?)\n---\n/.exec(content.replace(/\r\n/g, '\n'));
+    if (frontMatter === null) {
+        throw new Error(`generated skill missing YAML front matter: ${sourcePath}`);
+    }
+    const yaml = frontMatter[1] ?? '';
+    if (!/^name:\s*\S+/m.test(yaml)) {
+        throw new Error(`generated skill missing name: ${sourcePath}`);
+    }
+    if (!/^description:\s*(?:\S|>\s*$)/m.test(yaml)) {
+        throw new Error(`generated skill missing description: ${sourcePath}`);
+    }
+}
+function extractSkillDescription(content) {
+    const normalized = content.replace(/\r\n/g, '\n');
+    const simple = /^description:\s*['"]?(.+?)['"]?\s*$/m.exec(normalized);
+    if (simple?.[1]) {
+        return simple[1].trim();
+    }
+    const folded = /^description:\s*>\s*\n((?:[ \t]+.+\n?)+)/m.exec(normalized);
+    return folded?.[1]
+        ? folded[1].split('\n').map((line) => line.trim()).filter(Boolean).join(' ')
+        : '';
+}

package/dist/config-tree.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureConfigRootLayout = ensureConfigRootLayout;
 exports.ensureConfigRootGitignore = ensureConfigRootGitignore;
 exports.ensureDefaultGlobalTemplates = ensureDefaultGlobalTemplates;
+exports.ensurePortableSystemdFiles = ensurePortableSystemdFiles;
 exports.migrateOldTemplates = migrateOldTemplates;
 exports.findLegacyProfileDirs = findLegacyProfileDirs;
 exports.findProfileDirs = findProfileDirs;
 exports.convertLegacyTemplateVars = convertLegacyTemplateVars;
 exports.migrateCodexRuntimeFiles = migrateCodexRuntimeFiles;
 exports.migrateLooseFiles = migrateLooseFiles;
+exports.describeLegacyProfileLayout = describeLegacyProfileLayout;
+exports.migrateProfileLayout = migrateProfileLayout;
 exports.starterConfigRootPath = starterConfigRootPath;
 exports.copySkeletonTree = copySkeletonTree;
+const childProcess = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
@@ -68,6 +72,25 @@ function ensureDefaultGlobalTemplates(configRoot) {
         }
     }
 }
+function ensurePortableSystemdFiles(configRoot) {
+    const packageRoot = path.resolve(__dirname, '..');
+    const files = new Map([
+        ['install-systemd-jobs.sh', { source: 'scripts/install-systemd-jobs.sh', mode: 0o755 }],
+        ['update-ai-tools.sh', { source: 'scripts/update-ai-tools.sh', mode: 0o755 }],
+        ['ai-tools-update.service', { source: 'ops/systemd/ai-tools-update.service', mode: 0o644 }],
+        ['ai-tools-update.timer', { source: 'ops/systemd/ai-tools-update.timer', mode: 0o644 }]
+    ]);
+    for (const [targetName, asset] of files) {
+        const sourcePath = path.join(packageRoot, asset.source);
+        const targetPath = path.join(configRoot, targetName);
+        if (!fs.existsSync(sourcePath)) {
+            continue;
+        }
+        fs.copyFileSync(sourcePath, targetPath);
+        fs.chmodSync(targetPath, asset.mode);
+        (0, utils_1.verbose)(`updated ${targetPath}`);
+    }
+}
 function migrateOldTemplates(configRoot) {
     const oldCodeTemplate = path.join(configRoot, 'templates', 'AGENTS-CODE.md');
     const newCodeTemplate = path.join(configRoot, 'global', 'agents', 'code.md.njk');
@@ -150,6 +173,232 @@ function migrateLooseFiles(agentDir, pattern, targetDirName) {
     }
     return moved;
 }
+function describeLegacyProfileLayout(profileDir) {
+    const paths = [];
+    const legacyMemoryDir = path.join(profileDir, 'memory');
+    if (fs.existsSync(legacyMemoryDir)) {
+        paths.push(legacyMemoryDir);
+    }
+    for (const filePath of legacyProjectMemoryFiles(profileDir)) {
+        paths.push(filePath);
+    }
+    const legacyCodexHome = path.join(profileDir, 'memories', 'codex-home');
+    if (fs.existsSync(legacyCodexHome) || (0, utils_1.isSymlink)(legacyCodexHome)) {
+        paths.push(legacyCodexHome);
+    }
+    return [...new Set(paths)].sort();
+}
+function migrateProfileLayout(configRoot, profileDir, confirmGitMoves) {
+    const projectMoves = planProjectMemoryMoves(profileDir);
+    validateMoveTargets(projectMoves);
+    const git = findGitWorktree(configRoot);
+    const trackedMoves = git === null ? [] : projectMoves.filter((move) => isTrackedByGit(git, move.source));
+    if (git !== null && trackedMoves.length > 0 && !confirmGitMoves({ gitRoot: git.root, moves: trackedMoves })) {
+        throw new Error('profile layout migration declined; no files were moved');
+    }
+    let gitMoves = 0;
+    for (const move of projectMoves) {
+        fs.mkdirSync(path.dirname(move.target), { recursive: true });
+        if (git !== null && trackedMoves.includes(move)) {
+            runGitMove(git, move);
+            gitMoves += 1;
+        }
+        else {
+            fs.renameSync(move.source, move.target);
+        }
+        removeEmptyParents(path.dirname(move.source), profileDir);
+        (0, utils_1.verbose)(`moved project memory ${move.source} -> ${move.target}`);
+    }
+    removeEmptyParents(path.join(profileDir, 'memory'), profileDir);
+    removeEmptyParents(path.join(profileDir, 'memories'), profileDir);
+    const runtimeMoves = migrateLegacyCodexHome(profileDir);
+    return { gitMoves, projectMemoryMoves: projectMoves.length, runtimeMoves };
+}
+function planProjectMemoryMoves(profileDir) {
+    const targetDir = path.join(profileDir, 'notes', 'memory');
+    const moves = [];
+    const legacyMemoryDir = path.join(profileDir, 'memory');
+    for (const source of listTreeFiles(legacyMemoryDir)) {
+        moves.push({ source, target: path.join(targetDir, path.relative(legacyMemoryDir, source)) });
+    }
+    for (const source of legacyProjectMemoryFiles(profileDir)) {
+        moves.push({ source, target: path.join(targetDir, path.basename(source)) });
+    }
+    return moves.sort((left, right) => left.source.localeCompare(right.source));
+}
+function legacyProjectMemoryFiles(profileDir) {
+    const files = [];
+    for (const entry of safeReadDir(profileDir)) {
+        if (entry.isFile() && /^memory.*\.md$/i.test(entry.name)) {
+            files.push(path.join(profileDir, entry.name));
+        }
+    }
+    const legacyMemoriesDir = path.join(profileDir, 'memories');
+    for (const entry of safeReadDir(legacyMemoriesDir)) {
+        if (entry.isFile() && /\.md$/i.test(entry.name)) {
+            files.push(path.join(legacyMemoriesDir, entry.name));
+        }
+    }
+    return files.sort();
+}
+function safeReadDir(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function listTreeFiles(root) {
+    const files = [];
+    for (const entry of safeReadDir(root)) {
+        const filePath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listTreeFiles(filePath));
+        }
+        else if (entry.isFile() || entry.isSymbolicLink()) {
+            files.push(filePath);
+        }
+    }
+    return files;
+}
+function validateMoveTargets(moves) {
+    const targets = new Set();
+    for (const move of moves) {
+        const target = path.resolve(move.target);
+        if (targets.has(target) || fs.existsSync(target) || (0, utils_1.isSymlink)(target)) {
+            throw new Error(`cannot migrate project memory because the destination already exists: ${move.target}`);
+        }
+        targets.add(target);
+    }
+}
+function findGitWorktree(configRoot) {
+    const searchPath = process.env.AGENT_RUN_REAL_PATH ?? process.env.PATH ?? '';
+    const gitCommand = findCommandOnPath('git', searchPath);
+    if (gitCommand === null) {
+        return null;
+    }
+    const env = { ...process.env, PATH: searchPath };
+    const result = childProcess.spawnSync(gitCommand, ['-C', configRoot, 'rev-parse', '--show-toplevel'], {
+        encoding: 'utf8',
+        env,
+        shell: false
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const root = result.stdout.trim();
+    return root ? { command: gitCommand, env, root: path.resolve(root) } : null;
+}
+function findCommandOnPath(command, searchPath) {
+    const extensions = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const dir of searchPath.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = path.join(dir, `${command}${extension}`);
+            try {
+                fs.accessSync(candidate, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+                return candidate;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function isTrackedByGit(git, filePath) {
+    const relativePath = path.relative(git.root, filePath).replace(/\\/g, '/');
+    const result = childProcess.spawnSync(git.command, ['-C', git.root, '--literal-pathspecs', 'ls-files', '--error-unmatch', '--', relativePath], { encoding: 'utf8', env: git.env, shell: false });
+    return result.status === 0;
+}
+function runGitMove(git, move) {
+    const source = path.relative(git.root, move.source).replace(/\\/g, '/');
+    const target = path.relative(git.root, move.target).replace(/\\/g, '/');
+    const result = childProcess.spawnSync(git.command, ['-C', git.root, '--literal-pathspecs', 'mv', '--', source, target], {
+        encoding: 'utf8',
+        env: git.env,
+        shell: false
+    });
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`;
+        throw new Error(`cannot migrate tracked project memory ${move.source}: ${detail}`);
+    }
+}
+function migrateLegacyCodexHome(profileDir) {
+    const source = path.join(profileDir, 'memories', 'codex-home');
+    if (!fs.existsSync(source) && !(0, utils_1.isSymlink)(source)) {
+        return 0;
+    }
+    const target = path.join(profileDir, constants_1.LIVE_DIR_NAME, 'memories', 'codex-home');
+    if (!fs.existsSync(target) && !(0, utils_1.isSymlink)(target)) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.renameSync(source, target);
+        removeEmptyParents(path.dirname(source), profileDir);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${target}`);
+        return 1;
+    }
+    const sourceIsDirectory = !(0, utils_1.isSymlink)(source) && fs.statSync(source).isDirectory();
+    const targetIsDirectory = !(0, utils_1.isSymlink)(target) && fs.statSync(target).isDirectory();
+    if (!sourceIsDirectory || !targetIsDirectory) {
+        const backupTarget = (0, utils_1.nextBackupPath)(target);
+        fs.renameSync(source, backupTarget);
+        removeEmptyParents(path.dirname(source), profileDir);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${backupTarget}`);
+        return 1;
+    }
+    const moved = mergeRuntimeTree(source, target);
+    removeEmptyParents(path.dirname(source), profileDir);
+    return moved;
+}
+function mergeRuntimeTree(sourceDir, targetDir) {
+    let moved = 0;
+    fs.mkdirSync(targetDir, { recursive: true });
+    for (const entry of safeReadDir(sourceDir)) {
+        const source = path.join(sourceDir, entry.name);
+        let target = path.join(targetDir, entry.name);
+        if (entry.isDirectory() && !entry.isSymbolicLink()) {
+            const targetIsDirectory = fs.existsSync(target) && !(0, utils_1.isSymlink)(target) && fs.statSync(target).isDirectory();
+            if ((fs.existsSync(target) || (0, utils_1.isSymlink)(target)) && !targetIsDirectory) {
+                target = (0, utils_1.nextBackupPath)(target);
+            }
+            moved += mergeRuntimeTree(source, target);
+            continue;
+        }
+        const resolvedTarget = fs.existsSync(target) || (0, utils_1.isSymlink)(target) ? (0, utils_1.nextBackupPath)(target) : target;
+        fs.mkdirSync(path.dirname(resolvedTarget), { recursive: true });
+        fs.renameSync(source, resolvedTarget);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${resolvedTarget}`);
+        moved += 1;
+    }
+    try {
+        fs.rmdirSync(sourceDir);
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    return moved;
+}
+function removeEmptyParents(startDir, stopDir) {
+    let dir = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (dir !== stop && (0, utils_1.isSamePathOrDescendant)(dir, stop)) {
+        try {
+            fs.rmdirSync(dir);
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && ['ENOENT', 'ENOTEMPTY'].includes(String(error.code))) {
+                return;
+            }
+            throw error;
+        }
+        dir = path.dirname(dir);
+    }
+}
 function starterConfigRootPath() {
     return path.resolve(__dirname, '..', 'examples', 'basic-config', 'agent-config');
 }

package/dist/constants.js

@@ -11,7 +11,7 @@ exports.LIVE_DIR_NAME = 'live';
 exports.CONFIG_ROOT_OVERRIDE_ENV = 'AGENT_RUN_CONFIG_ROOT_OVERRIDE';
 exports.CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
 exports.VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
-exports.PACKAGE_VERSION = '0.99.28';
+exports.PACKAGE_VERSION = '0.99.30';
 exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.md',
@@ -19,10 +19,11 @@ exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.override.md',
     'CLAUDE.md',
     'CLAUDE.local.md',
+    'GEMINI.md',
     '.mcp.json',
     'codex.md'
 ]);
-exports.LOCAL_AI_DIRECTORY_NAMES = new Set(['.agents', '.claude', '.codex']);
+exports.LOCAL_AI_DIRECTORY_NAMES = new Set(['.agents', '.claude', '.codex', '.gemini', '.grok']);
 exports.GENERATED_GITIGNORE_ENTRIES = [
     '# Generated agent-run live profiles',
     '**/live/',
@@ -55,6 +56,8 @@ exports.REQUIRED_GLOBAL_TEMPLATES = [
     'global/snippets/verification.md.njk',
     'global/tool-templates/codex-config.toml.njk',
     'global/tool-templates/claude-settings.json.njk',
+    'global/tool-templates/gemini-settings.json.njk',
+    'global/tool-templates/grok-config.toml.njk',
     'global/skills/commit-workflow/SKILL.md.njk',
     'global/skills/github-release/SKILL.md.njk',
     'global/skills/release-package-check/SKILL.md.njk',

package/dist/defaults.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultManifest = defaultManifest;
 exports.stringifyRootDefaults = stringifyRootDefaults;
 exports.defaultLocalTemplate = defaultLocalTemplate;
+exports.defaultProjectMemoryIndex = defaultProjectMemoryIndex;
 exports.defaultGlobalTemplates = defaultGlobalTemplates;
 exports.defaultToolInstructionsTemplate = defaultToolInstructionsTemplate;
 exports.defaultCodexConfigContent = defaultCodexConfigContent;
 exports.defaultClaudeSettingsContent = defaultClaudeSettingsContent;
+exports.defaultGeminiSettingsContent = defaultGeminiSettingsContent;
+exports.defaultGrokConfigContent = defaultGrokConfigContent;
 exports.legacyDefaultClaudeSettingsContent = legacyDefaultClaudeSettingsContent;
 function defaultManifest(profile) {
     return {
@@ -21,8 +24,11 @@ function defaultManifest(profile) {
         },
         tools: {
             codex: true,
-            claude: true
+            claude: true,
+            gemini: true,
+            grok: true
         },
+        mcp: { servers: {} },
         checks: ['agent-run check .', 'pnpm run cleanbuild'],
         guardrails: {
             blockGitWrite: true,
@@ -34,7 +40,8 @@ function defaultManifest(profile) {
             changesFile: '{{ projectRoot }}/CHANGES',
             reviewDir: '{{ profileDir }}/reviews',
             reviewFile: '{{ profileDir }}/reviews/REVIEW-{{ date }}.md',
-            memoriesDir: '{{ agentDir }}/memories'
+            memoriesDir: '{{ agentDir }}/memories',
+            projectMemoryDir: '{{ profileDir }}/notes/memory'
         }
     };
 }
@@ -71,6 +78,19 @@ function defaultLocalTemplate() {
         ''
     ].join('\n');
 }
+function defaultProjectMemoryIndex() {
+    return [
+        '# Project memory',
+        '',
+        'This directory contains durable notes for this project across agent sessions and machines.',
+        'Keep the notes short, factual, and free of secrets. Link additional topic files from this index.',
+        '',
+        '## Files',
+        '',
+        '- Add project memory files here as they are needed.',
+        ''
+    ].join('\n');
+}
 function defaultGlobalTemplates() {
     return new Map([
         ['global/agents/code.md.njk', defaultCodeAgentTemplate()],
@@ -80,6 +100,8 @@ function defaultGlobalTemplates() {
         ['global/snippets/verification.md.njk', defaultVerificationSnippet()],
         ['global/tool-templates/codex-config.toml.njk', defaultCodexConfigTemplate()],
         ['global/tool-templates/claude-settings.json.njk', defaultClaudeSettingsTemplate()],
+        ['global/tool-templates/gemini-settings.json.njk', defaultGeminiSettingsTemplate()],
+        ['global/tool-templates/grok-config.toml.njk', defaultGrokConfigTemplate()],
         ['global/skills/commit-workflow/SKILL.md.njk', defaultCommitWorkflowSkill()],
         ['global/skills/github-release/SKILL.md.njk', defaultGithubReleaseSkill()],
         ['global/skills/release-package-check/SKILL.md.njk', defaultReleasePackageCheckSkill()],
@@ -123,7 +145,7 @@ function defaultNoAiFilesSnippet() {
     return [
         '## Agent File Storage',
         '',
-        'Do not create AGENTS.md, CLAUDE.md, .agents, .claude, .codex, or other agent runtime files inside the project repository.',
+        'Do not create AGENTS.md, CLAUDE.md, GEMINI.md, .agents, .claude, .codex, .gemini, .grok, or other agent runtime files inside the project repository.',
         'Generated agent-only files belong under {{ paths.liveDir }}.',
         'Source config files belong under {{ profileDir }}.',
         ''
@@ -196,7 +218,7 @@ function defaultReleasePackageCheckSkill() {
         '- The year in the top `CHANGES` version line appears in `package.json.copyright`.',
         '- The git `origin` remote matches `<org>/<repo>`.',
         '- The current branch has an upstream configured and is in sync with it after fetching.',
-        '- The repository does not contain agent files or directories such as `AGENTS.md`, `CLAUDE.md`, `codex.md`, `.claude`, or `.codex`.',
+        '- The repository does not contain agent files or directories such as `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `codex.md`, `.claude`, `.codex`, `.gemini`, or `.grok`.',
         '- The repository root has a lockfile: `pnpm-lock.yaml`, `package-lock.json`, `yarn.lock`, `bun.lockb`, or `bun.lock`.',
         '- Every GitHub Actions `uses:` reference is pinned to a full commit SHA.',
         '- The pinned `actions/setup-node` release is v6-compatible and workflows use `node-version: 24`.',
@@ -293,6 +315,18 @@ function defaultToolInstructionsTemplate(isClaude) {
         '{{ paths.memoriesDir }}',
         '```',
         '',
+        'Project memory directory:',
+        '',
+        '```text',
+        '{{ paths.projectMemoryDir }}',
+        '```',
+        '',
+        'Native Codex memory directory:',
+        '',
+        '```text',
+        '{{ paths.nativeMemoryDir }}',
+        '```',
+        '',
         'Global memory directory:',
         '',
         '```text',
@@ -315,11 +349,11 @@ function defaultToolInstructionsTemplate(isClaude) {
         '',
         isClaude
             ? 'Claude receives {{ agentDir }}/CLAUDE.md through `--append-system-prompt-file` and loads generated skills as a local plugin.'
-            : 'Codex loads AGENTS.md, config.toml, and skills natively from {{ paths.codexHomeDir }}.',
+            : 'Codex, Gemini, and Grok load this canonical AGENTS.md content from their private agent-run runtimes.',
         '',
         '## Mandatory Path Rule',
         '',
-        'Do not create AGENTS.md, CLAUDE.md, .agents, .claude, .codex, or AI-related files inside the project repository.',
+        'Do not create AGENTS.md, CLAUDE.md, GEMINI.md, .agents, .claude, .codex, .gemini, .grok, or AI-related files inside the project repository.',
         'Generated agent-only files must be stored under the agent directory shown above.',
         'Source config files must be stored under the profile source directory shown above.',
         ''
@@ -337,7 +371,8 @@ function defaultCodexConfigTemplate() {
         'writable_roots = [',
         '  {{ projectRoot | dump }},',
         '  {{ paths.reviewDir | dump }},',
-        '  {{ paths.memoriesDir | dump }}',
+        '  {{ paths.memoriesDir | dump }},',
+        '  {{ paths.projectMemoryDir | dump }}',
         ']',
         'network_access = false',
         ''
@@ -349,6 +384,7 @@ function defaultClaudeSettingsTemplate() {
         '    "AGENT_DIR": {{ agentDir | dump }},',
         '    "AGENT_PROFILE_DIR": {{ profileDir | dump }},',
         '    "AGENT_RUN_PROJECT_ROOT": {{ projectRoot | dump }},',
+        '    "AGENT_PROJECT_MEMORY_DIR": {{ paths.projectMemoryDir | dump }},',
         '    "AGENT_GLOBAL_MEMORY_DIR": {{ paths.globalMemoryDir | dump }}',
         '  }'
     ].join('\n');
@@ -365,6 +401,19 @@ function defaultClaudeSettingsTemplate() {
         '{% endif %}'
     ].join('\n');
 }
+function defaultGeminiSettingsTemplate() {
+    return [
+        '{',
+        '  "general": {',
+        '    "enableAutoUpdate": true',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+}
+function defaultGrokConfigTemplate() {
+    return ['# Generated by agent-run. Do not edit directly.', ''].join('\n');
+}
 function defaultCodexConfigContent(context) {
     return [
         '# Generated by agent-run. Do not edit directly.',
@@ -377,7 +426,8 @@ function defaultCodexConfigContent(context) {
         'writable_roots = [',
         `  ${JSON.stringify(context.projectRoot)},`,
         `  ${JSON.stringify(context.paths.reviewDir)},`,
-        `  ${JSON.stringify(context.paths.memoriesDir)}`,
+        `  ${JSON.stringify(context.paths.memoriesDir)},`,
+        `  ${JSON.stringify(context.paths.projectMemoryDir)}`,
         ']',
         'network_access = false',
         ''
@@ -389,6 +439,7 @@ function defaultClaudeSettingsContent(context) {
             AGENT_DIR: context.agentDir,
             AGENT_PROFILE_DIR: context.profileDir,
             AGENT_RUN_PROJECT_ROOT: context.projectRoot,
+            AGENT_PROJECT_MEMORY_DIR: context.paths.projectMemoryDir,
             AGENT_GLOBAL_MEMORY_DIR: context.paths.globalMemoryDir
         }
     };
@@ -397,6 +448,12 @@ function defaultClaudeSettingsContent(context) {
     }
     return `${JSON.stringify(settings, null, 2)}\n`;
 }
+function defaultGeminiSettingsContent(_context) {
+    return `${JSON.stringify({ general: { enableAutoUpdate: true } }, null, 2)}\n`;
+}
+function defaultGrokConfigContent() {
+    return '# Generated by agent-run. Do not edit directly.\n';
+}
 function legacyDefaultClaudeSettingsContent(context, agentDir) {
     return `${JSON.stringify({
         env: {

package/dist/manifest.js

@@ -100,6 +100,11 @@ function mergeManifest(base, override, allowProfile, inferredProfile) {
         agent: { ...base.agent, ...override.agent },
         skills: mergeSkills(base.skills, override.skills),
         tools: { ...base.tools, ...override.tools },
+        mcp: {
+            ...base.mcp,
+            ...override.mcp,
+            servers: { ...base.mcp?.servers, ...override.mcp?.servers }
+        },
         guardrails: { ...base.guardrails, ...override.guardrails },
         paths: { ...base.paths, ...override.paths }
     };
@@ -151,8 +156,11 @@ function normalizeManifest(manifest, profile) {
         },
         tools: {
             codex: manifest.tools?.codex ?? true,
-            claude: manifest.tools?.claude ?? true
+            claude: manifest.tools?.claude ?? true,
+            gemini: manifest.tools?.gemini ?? true,
+            grok: manifest.tools?.grok ?? true
         },
+        mcpServers: normalizeMcpServers(manifest.mcp?.servers ?? {}),
         checks: manifest.checks ?? fallback.checks ?? [],
         guardrails: {
             blockGitWrite: manifest.guardrails?.blockGitWrite ?? true,
@@ -165,10 +173,39 @@ function normalizeManifest(manifest, profile) {
             reviewDir: normalizeLegacyReviewPath(paths.reviewDir ?? fallbackPaths.reviewDir ?? '{{ profileDir }}/reviews'),
             reviewFile: normalizeLegacyReviewPath(paths.reviewFile ?? fallbackPaths.reviewFile ?? '{{ profileDir }}/reviews/REVIEW-{{ date }}.md'),
             reviewConsolidatedFile: paths.reviewConsolidatedFile ?? fallbackPaths.reviewConsolidatedFile,
-            memoriesDir: paths.memoriesDir ?? fallbackPaths.memoriesDir ?? '{{ agentDir }}/memories'
+            memoriesDir: paths.memoriesDir ?? fallbackPaths.memoriesDir ?? '{{ agentDir }}/memories',
+            projectMemoryDir: paths.projectMemoryDir ?? fallbackPaths.projectMemoryDir ?? '{{ profileDir }}/notes/memory'
         }
     };
 }
+function normalizeMcpServers(servers) {
+    const normalized = {};
+    for (const [name, server] of Object.entries(servers ?? {})) {
+        if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+            throw new Error(`invalid MCP server name: ${name}`);
+        }
+        const transport = server.transport ?? (server.command ? 'stdio' : 'http');
+        if (transport === 'stdio') {
+            if (!server.command?.trim() || server.url !== undefined) {
+                throw new Error(`MCP server ${name} must set command and must not set url for stdio transport`);
+            }
+        }
+        else if (!server.url?.trim() || server.command !== undefined) {
+            throw new Error(`MCP server ${name} must set url and must not set command for ${transport} transport`);
+        }
+        normalized[name] = {
+            transport,
+            ...(server.command ? { command: server.command } : {}),
+            args: server.args ?? [],
+            ...(server.cwd ? { cwd: server.cwd } : {}),
+            env: server.env ?? {},
+            ...(server.url ? { url: server.url } : {}),
+            headers: server.headers ?? {},
+            enabled: server.enabled ?? true
+        };
+    }
+    return normalized;
+}
 function normalizeInstalledSkills(names) {
     return [...new Set(names.map(normalizeSkillName))];
 }