@technomoron/agent-run 0.99.29 → 0.99.30

package/dist/cli.js

@@ -4,6 +4,8 @@ exports.parseInvocation = parseInvocation;
 const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
+const registry_1 = require("./agents/registry");
+const types_1 = require("./agents/types");
 const project_1 = require("./project");
 const utils_1 = require("./utils");
 function parseInvocation(invokedTool, argv) {
@@ -25,7 +27,7 @@ function applyGlobalOptions(options) {
 }
 function extractCommand(args) {
     if (args.length === 0) {
-        (0, utils_1.fail)('usage: agent-run <codex|claude|check|setup|generate|edit|update> [options] (run with --help for details)');
+        (0, utils_1.fail)('usage: agent-run <codex|claude|gemini|grok|check|status|setup|generate|edit|update> [options] (run with --help for details)');
     }
     if (isHelpFlag(args[0])) {
         printHelp('general');
@@ -48,6 +50,8 @@ function parseCommand(command, args) {
     switch (command) {
         case 'check':
             return parseCheckCommand(args);
+        case 'status':
+            return parseStatusCommand(args);
         case 'init':
             return parseInitCommand(args);
         case 'generate':
@@ -162,7 +166,11 @@ function applySandboxRunOption(command, arg, options) {
     if (!['--yolo', '--sandboxed', '--network'].includes(arg)) {
         return false;
     }
-    if (arg !== '--yolo' && command !== 'codex') {
+    const adapter = (0, registry_1.getAgentAdapter)(command);
+    if (arg === '--sandboxed' && !adapter.wrapperOptions.sandboxed) {
+        (0, utils_1.fail)(`${arg} is not supported for agent-run ${command}`);
+    }
+    if (arg === '--network' && !adapter.wrapperOptions.network) {
         (0, utils_1.fail)(`${arg} is only supported for agent-run codex`);
     }
     if (arg === '--network') {
@@ -176,6 +184,15 @@ function applySandboxRunOption(command, arg, options) {
     options.sandboxMode = mode;
     return true;
 }
+function parseStatusCommand(inputArgs) {
+    for (const arg of inputArgs) {
+        if (isHelpFlag(arg)) {
+            printHelp('status');
+        }
+        (0, utils_1.fail)(`unknown status option: ${arg}`);
+    }
+    return { command: 'status' };
+}
 function parseCheckCommand(inputArgs) {
     let all = false;
     let targetPath = process.cwd();
@@ -298,6 +315,7 @@ function renderHelp(topic) {
             '  --all       Check every repo under path',
             ''
         ],
+        status: ['Usage:', '  agent-run status', '', 'Show the native agent capability matrix.', ''],
         init: ['Usage:', '  agent-run init [path]', '', 'Deprecated alias for `agent-run generate [path]`.', ''],
         generate: ['Usage:', '  agent-run generate [path]', '', 'Create a minimal mapped profile marker and render generated files.', ''],
         setup: ['Usage:', '  agent-run setup [org/repo]', '', 'Install the default config tree and selected profile.', ''],
@@ -328,15 +346,20 @@ function renderHelp(topic) {
         `agent-run ${agentRunVersion()}`,
         '',
         'Usage:',
-        '  agent-run <codex|claude|check|setup|generate|edit|update> [options]',
+        '  agent-run <codex|claude|gemini|grok|check|status|setup|generate|edit|update> [options]',
         '',
         'Commands:',
         '  codex [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [--network] [args...]',
         '                                           Run codex with generated private config',
         '  claude [--none] [--create] [--local] [--show] [--generate] [--yolo] [args...]',
         '                                           Run claude with generated private config',
+        '  gemini [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [args...]',
+        '                                           Run gemini with generated private config',
+        '  grok [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [args...]',
+        '                                           Run grok with generated private config',
         '  setup [org/repo]                      Install the default tree and selected profile',
         '  check [--all] [path]                  Validate generated profile output',
+        '  status                                Show native agent capabilities',
         '  generate [path]                       Create a sparse profile marker and render output',
         '  edit [path]                           Create or open local.md.njk',
         '  update [--all] [path]                 Regenerate existing profile output',
@@ -354,10 +377,11 @@ function renderHelp(topic) {
         '  --generate         Generate files without running the tool',
         '  --yolo             Run unattended without approval prompts:',
         '                     Codex with -a never -s danger-full-access,',
-        '                     Claude with --dangerously-skip-permissions',
+        '                     Claude with --dangerously-skip-permissions,',
+        '                     Gemini with --yolo, Grok with --always-approve',
         '',
-        'Codex wrapper options:',
-        '  --sandboxed        Run Codex with workspace-write sandbox (default)',
+        'Sandbox wrapper options:',
+        '  --sandboxed        Run Codex, Gemini, or Grok in its native workspace sandbox',
         '  --network          Enable network for the workspace-write sandbox',
         ''
     ].join('\n');
@@ -379,7 +403,7 @@ function normalizeCommandName(value) {
     if (base === 'agent-run') {
         return null;
     }
-    return ['codex', 'claude', 'check', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
+    return [...types_1.AGENT_IDS, 'check', 'status', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
         ? base
         : null;
 }

package/dist/commands.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const fs = require("fs");
 const path = require("path");
+const registry_1 = require("./agents/registry");
 const checks_1 = require("./checks");
 const cli_1 = require("./cli");
 const config_tree_1 = require("./config-tree");
@@ -11,7 +12,7 @@ const manifest_1 = require("./manifest");
 const process_1 = require("./process");
 const project_1 = require("./project");
 const renderer_1 = require("./renderer");
-const tools_1 = require("./tools");
+const spawn_agent_1 = require("./runtime/spawn-agent");
 const utils_1 = require("./utils");
 function main(invokedTool, argv) {
     dispatch((0, cli_1.parseInvocation)(invokedTool, argv));
@@ -21,6 +22,9 @@ function dispatch(command) {
         case 'check':
             runCheck(command);
             return;
+        case 'status':
+            runStatus(command);
+            return;
         case 'init':
             runGenerate(command);
             return;
@@ -45,13 +49,18 @@ function dispatch(command) {
 }
 function runTool(parsed) {
     const { args, command, wrapperArgs } = parsed;
+    const adapter = (0, registry_1.getAgentAdapter)(command);
     const projectRoot = (0, project_1.findProjectRoot)(process.cwd());
     (0, utils_1.verbose)(`run ${command}: cwd=${process.cwd()} projectRoot=${projectRoot}`);
     validateRunModes(parsed, projectRoot);
     if (wrapperArgs.none || (0, project_1.isIgnoredDir)(projectRoot)) {
         (0, utils_1.verbose)(`wrapper bypassed for ${command}${wrapperArgs.none ? ' via --none' : ' because project is ignored'}`);
-        const runtimeArgs = wrapperArgs.sandboxMode === 'danger' ? (0, tools_1.getDangerArgs)(command) : (0, tools_1.getPermissionArgs)(command);
-        (0, process_1.execTool)((0, process_1.findRealBinary)(command), [...runtimeArgs, ...args]);
+        (0, spawn_agent_1.spawnAgent)({
+            command: (0, process_1.findRealBinary)(command),
+            args: [...adapter.bypassArgs(wrapperArgs), ...args],
+            cwd: process.cwd(),
+            env: { ...process.env }
+        });
         return;
     }
     const profileResult = (0, project_1.resolveProfileResult)(projectRoot);
@@ -82,14 +91,29 @@ function runTool(parsed) {
     }
     checkLocalAiFiles(command, projectRoot, agentDir, preview.context, wrapperArgs.local);
     const realBinary = (0, process_1.findRealBinary)(command);
-    const permissionArgs = (0, tools_1.getPermissionArgs)(command);
     const rendered = (0, renderer_1.syncAgentProfile)(projectRoot, agentDir);
-    if (command === 'codex') {
-        (0, tools_1.runCodex)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
-    }
-    else {
-        (0, tools_1.runClaude)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
+    const runtime = rendered.runtimes[command];
+    if (!runtime) {
+        (0, utils_1.fail)(`no generated ${command} runtime found for profile ${rendered.profile}`);
     }
+    (0, spawn_agent_1.spawnAgent)(adapter.spawn(runtime, { binary: realBinary, passthroughArgs: args, wrapperArgs }));
+}
+function runStatus(_parsed) {
+    const adapters = (0, registry_1.listAgentAdapters)();
+    const columns = adapters.map((adapter) => adapter.displayName);
+    const capabilityRows = [
+        ['Instructions', 'instructions'],
+        ['Skills', 'skills'],
+        ['MCP', 'mcp'],
+        ['Hooks', 'hooks'],
+        ['Subagents', 'subagents'],
+        ['Headless', 'headless']
+    ];
+    const firstWidth = Math.max(...capabilityRows.map(([label]) => label.length));
+    const widths = columns.map((label) => Math.max(label.length, 3));
+    const header = `${''.padEnd(firstWidth)}  ${columns.map((label, index) => label.padStart(widths[index] ?? 3)).join('  ')}`;
+    const rows = capabilityRows.map(([label, capability]) => `${label.padEnd(firstWidth)}  ${adapters.map((adapter, index) => (adapter.capabilities[capability] ? 'yes' : '-').padStart(widths[index] ?? 3)).join('  ')}`);
+    process.stdout.write(['Native agent capabilities', '', header, ...rows, ''].join('\n'));
 }
 function validateRunModes(parsed, projectRoot) {
     const { command, wrapperArgs } = parsed;

package/dist/config/render-instructions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCanonicalInstructions = buildCanonicalInstructions;
+exports.writeAgentsMd = writeAgentsMd;
+exports.writeClaudeMd = writeClaudeMd;
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("../constants");
+const defaults_1 = require("../defaults");
+const templates_1 = require("../templates");
+function buildCanonicalInstructions(env, configRoot, manifest, context, trace) {
+    const sections = [(0, templates_1.renderTemplateFile)(env, configRoot, manifest.agent.base, context, trace)];
+    for (const include of manifest.agent.includes) {
+        const includePath = (0, templates_1.resolveConfigPath)(configRoot, include, context);
+        if (!fs.existsSync(includePath)) {
+            if (include.includes('AGENTS-MODS.md') || include.includes(constants_1.LOCAL_TEMPLATE_FILE_NAME)) {
+                continue;
+            }
+            throw new Error(`missing template: ${includePath}`);
+        }
+        sections.push((0, templates_1.renderTemplateFile)(env, configRoot, include, context, trace));
+    }
+    const renderedSections = sections.map((section, index) => {
+        const label = index === 0 ? manifest.agent.base : manifest.agent.includes[index - 1] ?? `section ${index}`;
+        (0, templates_1.assertNoUnexpandedTemplateVars)(label, section);
+        return section.trimEnd();
+    });
+    renderedSections.push(projectMemoryInstructions(context));
+    return { sections: renderedSections };
+}
+function writeAgentsMd(env, configRoot, context, trace) {
+    return renderInstructionFile('AGENTS.md', env, configRoot, context, false, trace);
+}
+function writeClaudeMd(env, configRoot, context, trace) {
+    return renderInstructionFile('CLAUDE.md', env, configRoot, context, true, trace);
+}
+function renderInstructionFile(templateName, env, configRoot, context, isClaude, trace) {
+    const templatePath = `global/tool-templates/${templateName}.njk`;
+    const content = fs.existsSync(path.join(configRoot, templatePath))
+        ? (0, templates_1.renderTemplateFile)(env, configRoot, templatePath, context, trace)
+        : env.renderString((0, defaults_1.defaultToolInstructionsTemplate)(isClaude), context);
+    (0, templates_1.assertNoUnexpandedTemplateVars)(templateName, content);
+    return content.replace(/\n*$/, '\n');
+}
+function projectMemoryInstructions(context) {
+    return [
+        '## Project Memory',
+        '',
+        `Project memory is stored in ${context.paths.projectMemoryDir}.`,
+        'Read README.md there before starting work when prior project context may matter, then read only the linked files relevant to the task.',
+        'Do not store secrets, raw chat transcripts, or temporary task state there.',
+        'Update project memory only when the user explicitly asks you to remember or update something for this project.'
+    ].join('\n');
+}

package/dist/config/render-mcp.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCodexMcp = renderCodexMcp;
+exports.renderGrokMcp = renderGrokMcp;
+exports.renderClaudeMcp = renderClaudeMcp;
+exports.renderGeminiMcp = renderGeminiMcp;
+function renderCodexMcp(context) {
+    return renderTomlMcp(context.mcpServers, 'codex');
+}
+function renderGrokMcp(context) {
+    return renderTomlMcp(context.mcpServers, 'grok');
+}
+function renderClaudeMcp(context) {
+    return { mcpServers: renderJsonMcp(context.mcpServers, 'claude') };
+}
+function renderGeminiMcp(context) {
+    return renderJsonMcp(context.mcpServers, 'gemini');
+}
+function renderJsonMcp(servers, target) {
+    const result = {};
+    for (const [name, server] of Object.entries(servers)) {
+        if (!server.enabled) {
+            continue;
+        }
+        if (server.transport === 'stdio') {
+            result[name] = compactObject({
+                ...(target === 'claude' ? { type: 'stdio' } : {}),
+                command: server.command,
+                args: server.args.length > 0 ? server.args : undefined,
+                cwd: server.cwd,
+                env: Object.keys(server.env).length > 0 ? server.env : undefined
+            });
+            continue;
+        }
+        result[name] = compactObject({
+            ...(target === 'claude' ? { type: server.transport } : {}),
+            ...(target === 'gemini' && server.transport === 'http'
+                ? { httpUrl: server.url }
+                : { url: server.url }),
+            headers: Object.keys(server.headers).length > 0 ? server.headers : undefined
+        });
+    }
+    return result;
+}
+function renderTomlMcp(servers, target) {
+    const sections = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const lines = [`[mcp_servers.${tomlKey(name)}]`];
+        if (server.transport === 'stdio') {
+            lines.push(`command = ${tomlString(server.command ?? '')}`);
+            if (server.args.length > 0) {
+                lines.push(`args = ${tomlArray(server.args)}`);
+            }
+            if (server.cwd) {
+                lines.push(`cwd = ${tomlString(server.cwd)}`);
+            }
+            if (Object.keys(server.env).length > 0) {
+                lines.push(`env = ${tomlInlineTable(server.env)}`);
+            }
+        }
+        else {
+            lines.push(`url = ${tomlString(server.url ?? '')}`);
+            if (Object.keys(server.headers).length > 0) {
+                lines.push(`${target === 'codex' ? 'http_headers' : 'headers'} = ${tomlInlineTable(server.headers)}`);
+            }
+        }
+        if (!server.enabled) {
+            lines.push('enabled = false');
+        }
+        sections.push(lines.join('\n'));
+    }
+    return sections.length > 0 ? `${sections.join('\n\n')}\n` : '';
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function tomlKey(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(', ')}]`;
+}
+function tomlInlineTable(values) {
+    return `{ ${Object.entries(values).map(([key, value]) => `${tomlKey(key)} = ${tomlString(value)}`).join(', ')} }`;
+}

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/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.29';
+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

@@ -8,6 +8,8 @@ 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 {
@@ -22,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,
@@ -95,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()],
@@ -138,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 }}.',
         ''
@@ -211,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`.',
@@ -342,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.',
         ''
@@ -394,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.',
@@ -428,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,
@@ -170,6 +178,34 @@ function normalizeManifest(manifest, profile) {
         }
     };
 }
+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))];
 }