@technomoron/agent-run 0.99.28 → 0.99.30

package/CHANGES

@@ -1,6 +1,32 @@
 CHANGES
 =======
 
+Version 0.99.30 (2026-09-06)
+----------------------------
+* Add native Gemini CLI and Grok Build adapters alongside Codex and Claude
+  Code, with private runtimes, shared instructions, skills, and MCP servers.
+* Add `agent-run gemini`, `agent-run grok`, and a native capability matrix
+  through `agent-run status`.
+* Keep vendor configuration and launch options behind a common adapter
+  interface, with native arguments passed through to the selected CLI.
+* Add Gemini and Grok to the AI tools updater, use fixed `/usr/local` paths,
+  install pnpm last, and remove recurring command-shim deletion.
+* Update the starter configuration, documentation, and integration tests for
+  all four native agents.
+
+Version 0.99.29 (2026-09-04)
+----------------------------
+* Add tracked per-profile project memory under `notes/memory`, while keeping
+  native Codex memories in ignored machine-local runtime state.
+* Detect older memory layouts before profile updates and agent launches, ask
+  before staging tracked moves with `git mv`, and support
+  `migrate-config --yes` for non-interactive migrations.
+* Make copied systemd updater files portable, install the helper under
+  `/usr/local/libexec`, and remove stale AI tool launchers before global
+  package updates.
+* Explain the shared configuration model for native coding agents in the
+  README.
+
 Version 0.99.28 (2026-08-30)
 ----------------------------
 * Add interactive `agent-run setup [org/repo]`, make `agent-run generate` the

package/README.md

@@ -1,9 +1,46 @@
 # agent-run
 
-Small wrapper for AI coding CLIs like Codex and Claude.
+**Config once. Run with any native coding agent.**
 
-It keeps agent files out of normal repos and stores them in a separate
-agent config tree. By default, that tree lives at `~/.agent-run`.
+`agent-run` lets you manage Codex, Claude Code, Gemini CLI, and Grok Build from
+one shared configuration system while continuing to use each vendor's native
+agent.
+
+Keep agent configuration in a separate Git repository instead of adding
+agent-specific files to every codebase. Define project instructions, skills,
+MCP servers, policies, and reusable configuration fragments once, then generate
+the native configuration each agent expects.
+
+Configuration is template-based using Nunjucks/Jinja-style templates, making it
+easy to build hierarchical setups from global defaults, organization rules,
+project-specific settings, reusable fragments, and local overrides.
+
+`agent-run` generates isolated agent runtimes outside the source repository, so
+application repositories remain clean and developers do not have to maintain
+separate `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, skills, and tool configuration
+for every agent.
+
+The core idea is simple:
+
+**One configuration repository. One set of skills. Multiple native agents.**
+
+```text
+shared config repository
+        ↓
+global + project + local templates
+        ↓
+canonical instructions / skills / MCP
+        ↓
+agent-specific generated runtime
+        ↓
+Codex | Claude Code | Gemini CLI | Grok Build
+```
+
+The native agents remain native. `agent-run` does not replace their execution
+engines, authentication, models, or tooling. It provides the portable
+configuration layer around them.
+
+**Config once, run anywhere.**
 
 ## Model
 
@@ -23,15 +60,27 @@ Example:
       agent-run.jsonc
       local.md.njk       # optional
       overrides/         # optional
+      notes/
+        memory/
+          README.md      # durable project memory, normally tracked
       live/
         CLAUDE.md
-        .claude/
+        .claude/         # Claude settings, MCP, and skills
         bin/
         memories/
           codex-home/
             AGENTS.md
             config.toml
+            memories/    # native Codex memory, local generated state
             skills/
+        gemini/
+          AGENTS.md
+          settings.json
+          home/          # private Gemini state and generated skills
+        grok/
+          AGENTS.md
+          config.toml
+          skills/
 ~/source/org/my-api/
 ```
 
@@ -50,15 +99,43 @@ the agent config tree.
 - `agent-run.jsonc`: sparse profile manifest and profile-discovery marker
 - `local.md.njk`: optional project-specific instructions
 - `overrides/`: optional per-profile template overrides
+- `notes/memory/`: durable project memory shared through the config repository
 - `live/memories/codex-home/AGENTS.md`: generated Codex instructions
 - `live/memories/codex-home/config.toml`: generated Codex config
 - `live/memories/codex-home/skills/`: generated Codex skills
 - `live/CLAUDE.md`: generated Claude instructions
-- `live/.claude/`: generated Claude settings and local plugin skills
+- `live/.claude/`: generated Claude settings, MCP configuration, and local
+  plugin skills
+- `live/gemini/`: generated Gemini instructions, settings, skills, and private
+  runtime state
+- `live/grok/`: generated Grok instructions, configuration, skills, and private
+  runtime state
 
 Edit only the root defaults and profile overrides that differ. `agent-run` keeps
 generated files in sync.
 
+## Native Agent Adapters
+
+Each supported CLI is isolated behind an adapter in `src/agents/`. The shared
+flow is:
+
+```text
+profile and templates
+        ↓
+canonical instructions, skills, and MCP servers
+        ↓
+Codex | Claude | Gemini | Grok adapter
+        ↓
+private generated runtime
+        ↓
+native vendor CLI in the real project directory
+```
+
+Codex, Gemini, and Grok receive the same generated `AGENTS.md` content. Claude
+receives a thin `CLAUDE.md` serialization of those same canonical instruction
+sections. Vendor-specific paths, settings formats, environment variables, and
+launch flags stay inside the matching adapter.
+
 ## Manifest Defaults
 
 Manifest values are resolved in this order:
@@ -78,6 +155,48 @@ A profile with no differences from the root defaults needs only this marker:
 {}
 ```
 
+Enable or disable native agents under `tools`:
+
+```json
+{
+  "tools": {
+    "codex": true,
+    "claude": true,
+    "gemini": true,
+    "grok": true
+  }
+}
+```
+
+MCP servers have one canonical manifest representation. A server uses either a
+local command or a remote URL:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "local-tools": {
+        "command": "node",
+        "args": ["/opt/team-mcp/server.js"],
+        "env": {
+          "TEAM": "docs"
+        }
+      },
+      "remote-tools": {
+        "transport": "http",
+        "url": "https://mcp.example.com/mcp",
+        "enabled": true
+      }
+    }
+  }
+}
+```
+
+`transport` may be `stdio`, `http`, or `sse`; it is inferred as `stdio` when
+`command` is present and `http` otherwise. The adapters serialize enabled
+servers into each CLI's native MCP format. Disabled servers remain disabled in
+Codex and Grok and are omitted from Claude and Gemini.
+
 `local.md.njk` and `overrides/` are not created unless they contain actual
 profile-specific configuration.
 
@@ -136,11 +255,11 @@ Global flag:
 - `-v`, `--verbose`: print path resolution, file creation, include expansion,
   generated file writes, and spawned commands
 
-`agent-run codex --help` and `agent-run claude --help` still pass `--help`
-through to the underlying tool.
+`agent-run codex --help`, `agent-run claude --help`, `agent-run gemini --help`,
+and `agent-run grok --help` pass `--help` through to the underlying tool.
 
-For `codex` and `claude`, use `--generate` to generate profile files without
-launching the underlying tool.
+For any native agent command, use `--generate` to generate profile files
+without launching the underlying tool.
 
 Codex defaults to `-a on-request -s workspace-write`. `agent-run` sets
 `CODEX_HOME` under the private agent directory, where Codex discovers the
@@ -152,6 +271,26 @@ When `~/.codex/auth.json` exists, profile-specific Codex homes link their
 `auth.json` to that shared login cache so changing profiles does not require a
 new ChatGPT login.
 
+### Project Memory
+
+Each profile has a durable `notes/memory/` directory outside the source repo.
+`README.md` is a short index; agents read only the linked files relevant to the
+current task. Agents may update project memory only when the user explicitly
+asks them to remember or update something for that project.
+
+Codex's native `$CODEX_HOME/memories/` remains under ignored `live/` state. It
+is generated, machine-local recall data and is not copied into the tracked
+project memory directory. Project memory is plain Markdown so it can be
+reviewed and shared through the Git repository that normally holds the
+`.agent-run` config tree.
+
+When a profile still uses `memory/`, loose `memory*.md` files, or Markdown files
+directly under the old `memories/` directory, agent-run detects the old layout
+before updating or launching an agent. If those files are tracked, agent-run
+shows the moves and asks before staging them with `git mv`. In a non-Git config
+tree, or for untracked files, it uses ordinary filesystem moves. Non-interactive
+runs stop with a command that can confirm the migration explicitly.
+
 Claude Code currently has no `--cd` equivalent. `agent-run` keeps Claude's
 process cwd at the project root, appends the generated `CLAUDE.md` with
 `--append-system-prompt-file`, passes generated settings with `--settings`, and
@@ -160,17 +299,38 @@ replace the user's normal `CLAUDE_CONFIG_DIR`. If Claude writes remembered
 permissions to `.claude/settings.local.json`, `agent-run` removes that file
 after the session unless `--local` was used.
 
-`--yolo` runs either tool unattended, with no approval prompts: Codex with
-`-a never -s danger-full-access`, Claude with `--dangerously-skip-permissions`.
+Gemini runs from the real project directory with a private
+`GEMINI_CLI_HOME`. Its generated system settings configure `AGENTS.md` as the
+context filename and add the private runtime plus project memory as context
+directories. Generated skills use Gemini's `.agents/skills` alias. Existing
+Gemini user settings, login credentials, commands, and user skills are linked
+into the private home when present; generated system settings remain the
+highest-priority project layer.
+
+Grok runs from the real project directory with `GROK_HOME` set to
+`live/grok/`. Grok natively reads the generated home-level `AGENTS.md`,
+`config.toml`, and `skills/`. Existing Grok login and MCP OAuth credential
+files are linked into the private runtime when present.
+
+`--yolo` runs the selected tool unattended, with no approval prompts: Codex
+with `-a never -s danger-full-access`, Claude with
+`--dangerously-skip-permissions`, Gemini with `--yolo`, and Grok with
+`--always-approve`.
 Only use it when the agent may change or delete anything it can reach. Claude
 refuses `--dangerously-skip-permissions` when it runs as root, so run it as a
-normal user. `--sandboxed` and `--network` stay Codex-only because Claude has no
-matching sandbox.
+normal user. `--sandboxed` selects the native workspace sandbox for Codex,
+Gemini, or Grok. `--network` remains Codex-only.
+
+By default, all four native agent commands fail when local AI files such as
+`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `.mcp.json`, `.agents`, `.claude`,
+`.codex`, `.gemini`, or `.grok` are present inside the project repository. Use
+`--local` to warn and continue for a specific invocation.
 
-By default, `agent-run codex` and `agent-run claude` fail when local AI files
-such as `AGENTS.md`, `CLAUDE.md`, `CLAUDE.local.md`, `.mcp.json`, `.agents`,
-`.claude`, or `.codex` are present inside the project repository. Use `--local`
-to warn and continue for a specific invocation.
+Show the native capability matrix:
+
+```sh
+agent-run status
+```
 
 Initialize mapped files for the current repo:
 
@@ -216,6 +376,8 @@ You can also generate from a tool command and stop before launch:
 ```sh
 agent-run codex --generate
 agent-run claude --generate
+agent-run gemini --generate
+agent-run grok --generate
 ```
 
 This reads the root defaults, sparse profile manifest, and Nunjucks templates,
@@ -226,12 +388,16 @@ then rewrites generated files:
 - `live/memories/codex-home/config.toml`
 - `live/memories/codex-home/skills/**`
 - `live/.claude/**`
+- `live/gemini/**`
+- `live/grok/**`
 - `live/bin/**`
 
 Per-profile override templates can be placed in:
 
 - `overrides/codex-config.toml.njk`
 - `overrides/claude-settings.json.njk`
+- `overrides/gemini-settings.json.njk`
+- `overrides/grok-config.toml.njk`
 
 ## Default Config Tree
 
@@ -274,8 +440,9 @@ This reports:
 
 - local AI files accidentally present in the source repo
 - missing mapped files
-- stale generated Codex instructions or config
-- invalid `CLAUDE.md`
+- stale generated instructions, settings, MCP configuration, or skills for any
+  enabled native agent
+- invalid generated JSON or skill metadata
 - profile resolution problems
 
 Check every repo under a source tree:
@@ -287,14 +454,17 @@ agent-run check --all ~/source
 Migrate an existing config tree to the manifest/template layout:
 
 ```sh
-agent-run migrate-config ~/.agent-run
+agent-run migrate-config --yes ~/.agent-run
 ```
 
 This preserves `AGENTS-MODS.md`, creates `local.md.njk` and a sparse
 `agent-run.jsonc` marker for legacy profiles, creates the root defaults and
 `global/` templates, moves loose review files into `reviews/`, moves loose
-`memory*.md` files into `memories/`, and moves old Codex runtime files into
-`live/memories/codex-home` without overwriting existing files.
+project memory files into each profile's `notes/memory/`, and moves old Codex
+runtime files into `live/memories/codex-home` without overwriting existing
+files. Use `--yes` to confirm tracked `git mv` operations in a non-interactive
+run. Omit `--yes` to review and confirm tracked moves interactively. The
+command stages moves but never commits them.
 
 ## Systemd Jobs
 
@@ -307,14 +477,20 @@ sudo scripts/install-systemd-jobs.sh --ai-tools
 ```
 
 This installs and enables `ai-tools-update.timer`, which runs hourly. The
-package list is configurable through systemd environment overrides:
+updater uses `/usr/local/bin/npm`, `/usr/local/bin/node`, and
+`/usr/local/bin/pnpm`, keeps global Node packages under `/usr/local`, and does
+not delete command shims during recurring runs. It updates this fixed list of
+Node packages with npm:
 
 ```text
-AI_TOOLS_NPM_PACKAGES="npm@latest pnpm@latest corepack@latest fallow@latest ripgrep@latest pm2@latest tsx@latest typescript@latest @openai/codex@latest @anthropic-ai/claude-code@latest @technomoron/agent-run@latest"
-AI_TOOLS_PNPM_PACKAGE="pnpm@latest"
-AI_TOOLS_APT_PACKAGES="gh"
+npm, pnpm, corepack, fallow, ripgrep, pm2, tsx, typescript,
+@openai/codex, @anthropic-ai/claude-code, @google/gemini-cli,
+@xai-official/grok, and @technomoron/agent-run
 ```
 
+The optional apt package list still defaults to `gh` and can be changed with
+`AI_TOOLS_APT_PACKAGES`.
+
 ## Login Warning
 
 For user-owned machines, `scripts/agent-config-login-warning.sh` can be called

package/dist/agents/claude.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeAdapter = void 0;
+const path = require("path");
+const render_mcp_1 = require("../config/render-mcp");
+const render_settings_1 = require("../config/render-settings");
+const render_skills_1 = require("../config/render-skills");
+const defaults_1 = require("../defaults");
+const environment_1 = require("../runtime/environment");
+const shared_1 = require("./shared");
+function layout(context) {
+    const dir = path.join(context.paths.liveDir, '.claude');
+    return {
+        dir,
+        instructionFile: path.join(context.paths.liveDir, 'CLAUDE.md'),
+        configFiles: [
+            path.join(dir, 'agent-run-settings.json'),
+            path.join(dir, 'mcp.json'),
+            path.join(dir, '.claude-plugin', 'plugin.json')
+        ],
+        skillsDir: context.paths.claudeSkillsDir,
+        requiredDirs: [dir, context.paths.claudeSkillsDir]
+    };
+}
+function generate(generation) {
+    const agentLayout = layout(generation.context);
+    const settingsContent = (0, render_settings_1.renderProfileConfig)(generation.env, generation.configRoot, generation.context, 'claude-settings.json.njk', 'global/tool-templates/claude-settings.json.njk', () => (0, defaults_1.defaultClaudeSettingsContent)(generation.context), 'Claude settings', generation.trace);
+    (0, render_settings_1.parseJsonObject)(settingsContent, 'Claude settings');
+    const files = [
+        { path: agentLayout.instructionFile, content: generation.claudeMd },
+        { path: agentLayout.configFiles[0] ?? '', content: settingsContent },
+        { path: agentLayout.configFiles[1] ?? '', content: `${JSON.stringify((0, render_mcp_1.renderClaudeMcp)(generation.context), null, 2)}\n` },
+        { path: agentLayout.configFiles[2] ?? '', content: pluginManifest(generation.context.profile) },
+        ...(0, render_skills_1.renderSkillFiles)(generation.context, agentLayout.skillsDir)
+    ];
+    return { ...agentLayout, id: 'claude', projectDir: generation.context.projectRoot, files, context: generation.context };
+}
+exports.claudeAdapter = {
+    id: 'claude',
+    displayName: 'Claude',
+    capabilities: {
+        instructions: true,
+        skills: true,
+        mcp: true,
+        hooks: true,
+        subagents: true,
+        headless: true
+    },
+    wrapperOptions: { sandboxed: false, network: false },
+    layout,
+    generate,
+    spawn(runtime, options) {
+        (0, shared_1.assertRuntimeFile)('claude', runtime.instructionFile, runtime.context.profileDir);
+        const forcedPermissionArgs = process.env.AGENT_WRAPPER_FORCE_PERMISSIVE === '1' &&
+            typeof process.getuid === 'function' && process.getuid() !== 0
+            ? ['--permission-mode', 'bypassPermissions']
+            : [];
+        const runtimeArgs = options.wrapperArgs.sandboxMode === 'danger'
+            ? ['--dangerously-skip-permissions']
+            : forcedPermissionArgs;
+        return {
+            command: options.binary,
+            args: [
+                ...runtimeArgs,
+                '--add-dir',
+                runtime.context.paths.projectMemoryDir,
+                '--append-system-prompt-file',
+                runtime.instructionFile,
+                '--settings',
+                runtime.configFiles[0] ?? '',
+                '--mcp-config',
+                runtime.configFiles[1] ?? '',
+                '--plugin-dir',
+                runtime.dir,
+                ...options.passthroughArgs
+            ],
+            cwd: runtime.projectDir,
+            env: (0, environment_1.buildAgentEnvironment)(runtime.context),
+            onExit: (0, shared_1.withPostflight)(runtime, options.wrapperArgs)
+        };
+    },
+    bypassArgs(wrapperArgs) {
+        return wrapperArgs.sandboxMode === 'danger' ? ['--dangerously-skip-permissions'] : [];
+    }
+};
+function pluginManifest(profile) {
+    return `${JSON.stringify({
+        name: 'agent-run-profile',
+        description: `Generated skills for agent-run profile ${profile}`,
+        version: '1.0.0',
+        author: { name: 'Technomoron' }
+    }, null, 2)}\n`;
+}

package/dist/agents/codex.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexAdapter = void 0;
+const os = require("os");
+const path = require("path");
+const defaults_1 = require("../defaults");
+const render_mcp_1 = require("../config/render-mcp");
+const render_settings_1 = require("../config/render-settings");
+const render_skills_1 = require("../config/render-skills");
+const environment_1 = require("../runtime/environment");
+const shared_state_1 = require("../runtime/shared-state");
+const shared_1 = require("./shared");
+function layout(context) {
+    return {
+        dir: context.paths.codexHomeDir,
+        instructionFile: path.join(context.paths.codexHomeDir, 'AGENTS.md'),
+        configFiles: [path.join(context.paths.codexHomeDir, 'config.toml')],
+        skillsDir: context.paths.codexSkillsDir,
+        requiredDirs: [context.paths.codexHomeDir, context.paths.codexSkillsDir],
+        preservedSkillNames: new Set(['.system'])
+    };
+}
+function generate(generation) {
+    const agentLayout = layout(generation.context);
+    const baseConfig = (0, render_settings_1.renderProfileConfig)(generation.env, generation.configRoot, generation.context, 'codex-config.toml.njk', 'global/tool-templates/codex-config.toml.njk', () => (0, defaults_1.defaultCodexConfigContent)(generation.context), 'Codex config.toml', generation.trace);
+    const mcp = (0, render_mcp_1.renderCodexMcp)(generation.context);
+    const files = [
+        { path: agentLayout.instructionFile, content: generation.agentsMd },
+        { path: agentLayout.configFiles[0] ?? '', content: `${baseConfig.trimEnd()}${mcp ? `\n\n${mcp}` : '\n'}` },
+        ...(0, render_skills_1.renderSkillFiles)(generation.context, agentLayout.skillsDir)
+    ];
+    return { ...agentLayout, id: 'codex', projectDir: generation.context.projectRoot, files, context: generation.context };
+}
+exports.codexAdapter = {
+    id: 'codex',
+    displayName: 'Codex',
+    capabilities: {
+        instructions: true,
+        skills: true,
+        mcp: true,
+        hooks: false,
+        subagents: true,
+        headless: true
+    },
+    wrapperOptions: { sandboxed: true, network: true },
+    layout,
+    generate,
+    prepare(runtime) {
+        (0, shared_state_1.linkSharedEntry)(path.join(os.homedir(), '.codex', 'auth.json'), path.join(runtime.dir, 'auth.json'), 'profile Codex auth');
+    },
+    spawn(runtime, options) {
+        (0, shared_1.assertRuntimeFile)('codex', runtime.instructionFile, runtime.context.profileDir);
+        const runtimeArgs = options.wrapperArgs.sandboxMode === 'danger'
+            ? ['-a', 'never', '-s', 'danger-full-access']
+            : ['-a', 'on-request', '-s', 'workspace-write'];
+        return {
+            command: options.binary,
+            args: [
+                ...runtimeArgs,
+                '--add-dir',
+                runtime.context.paths.projectMemoryDir,
+                '-C',
+                runtime.projectDir,
+                ...(options.wrapperArgs.sandboxMode !== 'danger' && options.wrapperArgs.codexNetwork
+                    ? ['--config', 'sandbox_workspace_write.network_access=true']
+                    : []),
+                ...options.passthroughArgs
+            ],
+            cwd: runtime.dir,
+            env: { ...(0, environment_1.buildAgentEnvironment)(runtime.context), CODEX_HOME: runtime.dir },
+            onExit: (0, shared_1.withPostflight)(runtime, options.wrapperArgs)
+        };
+    },
+    bypassArgs(wrapperArgs) {
+        return wrapperArgs.sandboxMode === 'danger' ? ['-a', 'never', '-s', 'danger-full-access'] : [];
+    }
+};

package/dist/agents/gemini.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiAdapter = void 0;
+const os = require("os");
+const path = require("path");
+const render_mcp_1 = require("../config/render-mcp");
+const render_settings_1 = require("../config/render-settings");
+const render_skills_1 = require("../config/render-skills");
+const defaults_1 = require("../defaults");
+const environment_1 = require("../runtime/environment");
+const shared_state_1 = require("../runtime/shared-state");
+const shared_1 = require("./shared");
+function layout(context) {
+    return {
+        dir: context.paths.geminiRuntimeDir,
+        instructionFile: path.join(context.paths.geminiRuntimeDir, 'AGENTS.md'),
+        configFiles: [path.join(context.paths.geminiRuntimeDir, 'settings.json')],
+        skillsDir: context.paths.geminiSkillsDir,
+        requiredDirs: [
+            context.paths.geminiRuntimeDir,
+            context.paths.geminiHomeDir,
+            context.paths.geminiSkillsDir
+        ]
+    };
+}
+function generate(generation) {
+    const agentLayout = layout(generation.context);
+    const baseSettings = (0, render_settings_1.parseJsonObject)((0, render_settings_1.renderProfileConfig)(generation.env, generation.configRoot, generation.context, 'gemini-settings.json.njk', 'global/tool-templates/gemini-settings.json.njk', () => (0, defaults_1.defaultGeminiSettingsContent)(generation.context), 'Gemini settings', generation.trace), 'Gemini settings');
+    const existingContext = asObject(baseSettings.context);
+    baseSettings.context = {
+        ...existingContext,
+        fileName: ['AGENTS.md'],
+        includeDirectories: [agentLayout.dir, generation.context.paths.projectMemoryDir],
+        loadMemoryFromIncludeDirectories: true,
+        fileFiltering: {
+            ...asObject(existingContext.fileFiltering),
+            respectGitIgnore: false
+        }
+    };
+    baseSettings.mcpServers = (0, render_mcp_1.renderGeminiMcp)(generation.context);
+    const files = [
+        { path: agentLayout.instructionFile, content: generation.agentsMd },
+        { path: agentLayout.configFiles[0] ?? '', content: `${JSON.stringify(baseSettings, null, 2)}\n` },
+        ...(0, render_skills_1.renderSkillFiles)(generation.context, agentLayout.skillsDir)
+    ];
+    return { ...agentLayout, id: 'gemini', projectDir: generation.context.projectRoot, files, context: generation.context };
+}
+exports.geminiAdapter = {
+    id: 'gemini',
+    displayName: 'Gemini',
+    capabilities: {
+        instructions: true,
+        skills: true,
+        mcp: true,
+        hooks: false,
+        subagents: true,
+        headless: true
+    },
+    wrapperOptions: { sandboxed: true, network: false },
+    layout,
+    generate,
+    prepare(runtime) {
+        const sharedGeminiDir = path.join(os.homedir(), '.gemini');
+        const privateGeminiDir = path.join(runtime.context.paths.geminiHomeDir, '.gemini');
+        for (const name of [
+            'settings.json',
+            'oauth_creds.json',
+            'google_accounts.json',
+            'trustedFolders.json',
+            'mcp-oauth-tokens.json',
+            'a2a-oauth-tokens.json',
+            'keybindings.json',
+            'installation_id',
+            'skills',
+            'commands'
+        ]) {
+            (0, shared_state_1.linkSharedEntry)(path.join(sharedGeminiDir, name), path.join(privateGeminiDir, name), `Gemini ${name}`);
+        }
+    },
+    spawn(runtime, options) {
+        (0, shared_1.assertRuntimeFile)('gemini', runtime.instructionFile, runtime.context.profileDir);
+        const modeArgs = options.wrapperArgs.sandboxMode === 'danger'
+            ? ['--yolo']
+            : options.wrapperArgs.sandboxMode === 'sandboxed'
+                ? ['--sandbox']
+                : [];
+        const sharedTrustedFolders = path.join(os.homedir(), '.gemini', 'trustedFolders.json');
+        return {
+            command: options.binary,
+            args: [...modeArgs, ...options.passthroughArgs],
+            cwd: runtime.projectDir,
+            env: {
+                ...(0, environment_1.buildAgentEnvironment)(runtime.context),
+                GEMINI_CLI_HOME: runtime.context.paths.geminiHomeDir,
+                GEMINI_CLI_SYSTEM_SETTINGS_PATH: runtime.configFiles[0],
+                GEMINI_CLI_TRUSTED_FOLDERS_PATH: sharedTrustedFolders
+            },
+            onExit: (0, shared_1.withPostflight)(runtime, options.wrapperArgs)
+        };
+    },
+    bypassArgs(wrapperArgs) {
+        if (wrapperArgs.sandboxMode === 'danger') {
+            return ['--yolo'];
+        }
+        return wrapperArgs.sandboxMode === 'sandboxed' ? ['--sandbox'] : [];
+    }
+};
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}