@specship/specship-darwin-arm64 0.29.0 → 0.30.0

package/lib/dist/installer/targets/gemini.js

@@ -8,8 +8,9 @@
  * slash commands rendered into Gemini TOML from the same
  * `commands/specship/*.md` sources the Claude target copies (REQ-GEMINI-005,
  * see `../gemini-commands.ts` for the verified format + per-command
- * decisions). What still has no Gemini equivalent (the `specship-explorer`
- * subagent, the status line, the permissions list) is left unwritten and
+ * decisions), plus the skills and the explorer subagent when the installed
+ * Gemini CLI supports them (REQ-AGENTSWITCH-005). What still has no Gemini
+ * equivalent (the status line, the permissions list) is left unwritten and
  * named in `notes` rather than half-installed (REQ-GEMINI-006).
  *
  * The target IS registered in `targets/registry.ts`, but a plain
@@ -65,13 +66,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.geminiTarget = exports.GeminiCliTarget = void 0;
+exports.geminiTarget = exports.GeminiCliTarget = exports.GEMINI_AGENT_MARKER = exports.GEMINI_SKILL_MARKER_FILE = exports.GEMINI_AGENTS_ON_BY_DEFAULT = exports.GEMINI_MIN_AGENTS = exports.GEMINI_MIN_SKILLS = exports.probeGeminiVersion = exports.geminiVersionSupports = exports.geminiMcpToolName = exports.GEMINI_FOLDER_TRUST_NOTE = void 0;
 exports.settingsPath = settingsPath;
 exports.writeGeminiInstructionsEntry = writeGeminiInstructionsEntry;
 exports.removeGeminiInstructionsEntry = removeGeminiInstructionsEntry;
 exports.writeGeminiSddEntry = writeGeminiSddEntry;
 exports.removeGeminiSddEntry = removeGeminiSddEntry;
 exports.writeGeminiMcpEntry = writeGeminiMcpEntry;
+exports.writeGeminiContextFilesEntry = writeGeminiContextFilesEntry;
+exports.removeGeminiContextFilesEntry = removeGeminiContextFilesEntry;
 exports.geminiCommandsDir = geminiCommandsDir;
 exports.writeGeminiCommandsEntries = writeGeminiCommandsEntries;
 exports.removeGeminiCommandsEntries = removeGeminiCommandsEntries;
@@ -82,13 +85,28 @@ exports.removeGeminiSddHooksEntry = removeGeminiSddHooksEntry;
 exports.renderGeminiPolicyToml = renderGeminiPolicyToml;
 exports.writeGeminiPolicyEntry = writeGeminiPolicyEntry;
 exports.removeGeminiPolicyEntry = removeGeminiPolicyEntry;
+exports.geminiSkillsDir = geminiSkillsDir;
+exports.geminiAgentsDir = geminiAgentsDir;
+exports.writeGeminiSkillsEntries = writeGeminiSkillsEntries;
+exports.removeGeminiSkillsEntries = removeGeminiSkillsEntries;
+exports.renderGeminiExplorerAgent = renderGeminiExplorerAgent;
+exports.writeGeminiAgentsEntry = writeGeminiAgentsEntry;
+exports.removeGeminiAgentsEntry = removeGeminiAgentsEntry;
+const gemini_projects_1 = require("./gemini-projects");
 const fs = __importStar(require("fs"));
+const gemini_version_1 = require("../../workflows/agents/gemini-version");
+Object.defineProperty(exports, "geminiMcpToolName", { enumerable: true, get: function () { return gemini_version_1.geminiMcpToolName; } });
+Object.defineProperty(exports, "geminiVersionSupports", { enumerable: true, get: function () { return gemini_version_1.geminiVersionSupports; } });
+Object.defineProperty(exports, "probeGeminiVersion", { enumerable: true, get: function () { return gemini_version_1.probeGeminiVersion; } });
+const hook_output_1 = require("../../activation/hook-output");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const shared_1 = require("./shared");
 const instructions_template_1 = require("../instructions-template");
 const claude_1 = require("./claude");
-const gemini_commands_1 = require("../gemini-commands");
+const agent_record_1 = require("../agent-record");
+const feature_parity_1 = require("./feature-parity");
+const gemini_commands_1 = require("./gemini-commands");
 /** Gemini CLI's settings file for this location. */
 function settingsPath(loc) {
     return loc === 'global'
@@ -187,20 +205,126 @@ function writeGeminiMcpEntry(loc, integrations = []) {
     (0, shared_1.writeJsonFile)(file, existing);
     return { path: file, action };
 }
+/**
+ * Context file names as Gemini CLI reads them (REQ-AGENTSWITCH-009).
+ * Verified against gemini-cli 0.28.0 `settingsSchema` / `getCurrentGeminiMdFilename`:
+ * `context.fileName` is a string or a string array; when unset Gemini loads
+ * only its default (`GEMINI.md`). The legacy top-level `contextFileName` is
+ * the pre-v2 spelling of the same setting — read as the user's list, never
+ * written or removed by us.
+ */
+function contextFileNames(value) {
+    if (typeof value === 'string' && value.length > 0)
+        return [value];
+    if (Array.isArray(value)) {
+        const names = value.filter((v) => typeof v === 'string' && v.length > 0);
+        return names.length > 0 ? names : null;
+    }
+    return null;
+}
+/** The scope's project root as the record keys it; absent for global. */
+function recordRoot(loc) {
+    return loc === 'local' ? process.cwd() : undefined;
+}
+/**
+ * Point Gemini CLI at the user's own CLAUDE.md instead of copying it
+ * (REQ-AGENTSWITCH-009): add its file name to `context.fileName`, keeping
+ * every name the user already listed in their order and keeping Gemini's
+ * default (`GEMINI.md`) when the setting was unset. The CLAUDE.md file itself
+ * is never opened for writing.
+ *
+ * Local scope writes nothing — and records nothing — when the project has
+ * no CLAUDE.md. Global scope always adds the name: Gemini CLI resolves a
+ * bare context file name in `~/.gemini/` and in each project's directories
+ * (gemini-cli-core `memoryDiscovery`, verified against 0.28.0), so the
+ * user-wide setting is what makes Gemini read every project's own CLAUDE.md.
+ * It never reaches `~/.claude/CLAUDE.md` — the capability note says so.
+ * Idempotent: a re-run that finds the name already listed reports
+ * `unchanged`.
+ *
+ * Returns the file result (null when there was nothing to point at) and the
+ * names this call put into `context.fileName` that were not in it before.
+ */
+function writeGeminiContextFilesEntry(loc) {
+    const claudeMd = (0, claude_1.claudeMdPath)(loc);
+    if (loc === 'local' && !fs.existsSync(claudeMd))
+        return { file: null, added: [] };
+    const wanted = path.basename(claudeMd);
+    const geminiDefault = path.basename(geminiMdPath(loc));
+    const file = settingsPath(loc);
+    const existed = fs.existsSync(file);
+    const settings = (0, shared_1.readJsonFile)(file);
+    const context = settings.context && typeof settings.context === 'object' && !Array.isArray(settings.context)
+        ? settings.context
+        : undefined;
+    const explicit = contextFileNames(context?.fileName);
+    const base = explicit ?? contextFileNames(settings.contextFileName) ?? [geminiDefault];
+    const next = base.includes(wanted) ? [...base] : [...base, wanted];
+    if (explicit && (0, shared_1.jsonDeepEqual)(explicit, next)) {
+        return { file: { path: file, action: 'unchanged' }, added: [] };
+    }
+    const nextContext = context ? { ...context } : {};
+    nextContext.fileName = next;
+    settings.context = nextContext;
+    (0, shared_1.writeJsonFile)(file, settings);
+    const added = next.filter((n) => !(explicit ?? []).includes(n));
+    return { file: { path: file, action: existed ? 'updated' : 'created' }, added };
+}
+/**
+ * Inverse of `writeGeminiContextFilesEntry` (REQ-AGENTSWITCH-009.A4): drop
+ * only the names SpecShip recorded as added; every name the user listed
+ * stays. With no recorded list (record lost or rebuilt) the setting is left
+ * untouched — conservative by design. Removing the last name deletes
+ * `context.fileName`, and `context` when that leaves it empty.
+ */
+function removeGeminiContextFilesEntry(loc, added) {
+    if (!added || added.length === 0)
+        return null;
+    const file = settingsPath(loc);
+    if (!fs.existsSync(file))
+        return null;
+    const settings = (0, shared_1.readJsonFile)(file);
+    const context = settings.context;
+    if (!context || typeof context !== 'object' || Array.isArray(context))
+        return null;
+    const current = contextFileNames(context.fileName);
+    if (!current)
+        return null;
+    const remaining = current.filter((n) => !added.includes(n));
+    if (remaining.length === current.length)
+        return null;
+    if (remaining.length === 0) {
+        delete context.fileName;
+        if (Object.keys(context).length === 0)
+            delete settings.context;
+    }
+    else {
+        context.fileName = remaining;
+    }
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: 'removed' };
+}
 /**
  * What a Claude install provides that this one does not (REQ-GEMINI-006.A1).
  * One note, naming every still-unsupported surface. As of REQ-GEMINI-010 the
  * prompt / session / tool hooks DO have Gemini equivalents and are installed,
  * so the note no longer lists them; nor slash commands, which REQ-GEMINI-005
- * renders as Gemini TOML. What remains is the specship-explorer subagent, the
- * status line, and the permissions auto-allow list (REQ-GEMINI-009 covers the
- * opt-in policy file). A command the renderer had to exclude gets its own
- * note from `writeGeminiCommandsEntries`.
+ * renders as Gemini TOML; nor skills and the explorer subagent, which
+ * REQ-AGENTSWITCH-005 installs when the Gemini version supports them (with its
+ * own skip / experimental notes). Auto-allow is the policy file
+ * (REQ-GEMINI-009). Surfaces Gemini has no equivalent for (the status line)
+ * each get their own line from `noSurfaceNotes()` (REQ-AGENTSWITCH-010.A4).
+ * A command the renderer had to exclude gets its own note from
+ * `writeGeminiCommandsEntries`.
  */
 const CAPABILITY_NOTE = 'Gemini CLI install wires the MCP server, writes a GEMINI.md steering ' +
-    'block, installs prompt/session/tool hooks, and renders the /specship:* ' +
-    'slash commands as Gemini TOML. No specship-explorer subagent and no ' +
-    'status line — Gemini CLI has no equivalent surface. The tool playbook ' +
+    'block, installs prompt/session/tool hooks, renders the /specship:* ' +
+    'slash commands as Gemini TOML, and adds CLAUDE.md to Gemini\'s context ' +
+    'files so Gemini reads each project\'s CLAUDE.md in place (a project install ' +
+    'does this only when the project has one). Gemini never reads ' +
+    '~/.claude/CLAUDE.md — copy anything you need from it into ~/.gemini/GEMINI.md. ' +
+    'Skills and the specship-explorer subagent are installed when the Gemini ' +
+    'CLI version supports them (see the notes below). The tool playbook ' +
     'itself still lives in the MCP server instructions.';
 /**
  * Gemini CLI's custom-commands dir for this location (verified against
@@ -239,17 +363,17 @@ function isOurCommandFile(file) {
  * `commandsSourceDir` defaults to the packaged `commands/` dir — the same
  * one the Claude target copies from.
  */
-function writeGeminiCommandsEntries(loc, includeGovernance = true, commandsSourceDir = (0, shared_1.packageAssetPath)('commands')) {
+function writeGeminiCommandsEntries(loc, includeGovernance = true, commandsSourceDir = (0, shared_1.packageAssetPath)('commands'), skills = []) {
     const names = includeGovernance ? ALL_COMMAND_SOURCES : [...claude_1.RETRIEVAL_TIER_COMMANDS];
     const dir = geminiCommandsDir(loc);
     const files = [];
     const notes = [];
-    for (const cmd of (0, gemini_commands_1.geminiCommandSet)(commandsSourceDir, names)) {
+    for (const cmd of (0, gemini_commands_1.geminiCommandSet)(commandsSourceDir, names, { skills })) {
         const dest = path.join(dir, cmd.target);
         if (cmd.toml === undefined) {
             notes.push(`Gemini CLI: skipped /${cmd.target.replace(/\.toml$/, '').replace(/\//g, ':')} — ${cmd.excluded}.`);
             if (isOurCommandFile(dest)) {
-                fs.unlinkSync(dest);
+                (0, shared_1.removeFileSync)(dest);
                 files.push({ path: dest, action: 'removed' });
             }
             continue;
@@ -266,8 +390,7 @@ function writeGeminiCommandsEntries(loc, includeGovernance = true, commandsSourc
                 continue;
             }
         }
-        fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.writeFileSync(dest, cmd.toml);
+        (0, shared_1.atomicWriteFileSync)(dest, cmd.toml);
         files.push({ path: dest, action: existed ? 'updated' : 'created' });
     }
     return { files, notes };
@@ -314,13 +437,13 @@ const TRUST_POLICY_NOTE = 'Wrote ~/.gemini/policies/specship.toml allowing SpecS
     'tools. An administrator policy still overrides this file, and ' +
     'run_shell_command confirmations are unaffected.';
 /**
- * Gemini's project-level hooks only run when the user has marked the folder
- * as trusted — a local install points the user at that gate so hooks silently
- * failing to run isn't the first evidence something's off.
+ * Gemini CLI loads a project's GEMINI.md, hooks, skills, subagents and MCP
+ * servers only in a folder the user has trusted — on by default from 0.33.0.
+ * Every Gemini install and switch names that gate in one line, and SpecShip
+ * never writes Gemini's trustedFolders.json itself (REQ-AGENTSWITCH-018.A4).
  */
-const LOCAL_TRUST_NOTE = 'Gemini CLI runs project-level hooks only in folders you have marked as ' +
-    'trusted. If the SpecShip hooks seem inert in this project, open it once in ' +
-    'Gemini CLI and accept the trust prompt.';
+exports.GEMINI_FOLDER_TRUST_NOTE = 'Gemini CLI: trust this folder (accept the prompt when you open it, or run /permissions) ' +
+    'before Gemini loads SpecShip\'s project files — GEMINI.md, hooks, skills and the MCP server.';
 const GEMINI_HOOKS = [
     // Prompt-level retrieval nudge — mirror of Claude's UserPromptSubmit.
     {
@@ -550,8 +673,7 @@ function writeGeminiPolicyEntry() {
         if (!current.startsWith(GEMINI_POLICY_HEADER_MARKER))
             return { path: file, action: 'kept' };
     }
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, content);
+    (0, shared_1.atomicWriteFileSync)(file, content);
     return { path: file, action: existed ? 'updated' : 'created' };
 }
 /**
@@ -571,9 +693,197 @@ function removeGeminiPolicyEntry() {
     fs.unlinkSync(file);
     return { path: file, action: 'removed' };
 }
+/** The Gemini CLI version these surfaces were verified against. */
+exports.GEMINI_MIN_SKILLS = '0.28.0';
+exports.GEMINI_MIN_AGENTS = '0.28.0';
+/** First Gemini CLI release with subagents on by default (`experimental.enableAgents`, REQ-AGENTSWITCH-018.A6). */
+exports.GEMINI_AGENTS_ON_BY_DEFAULT = '0.36.0';
+/** Gemini CLI's skills dir for this location (same scope as `settingsPath`). */
+function geminiSkillsDir(loc) {
+    return path.join(path.dirname(settingsPath(loc)), 'skills');
+}
+/** Gemini CLI's subagents dir for this location. */
+function geminiAgentsDir(loc) {
+    return path.join(path.dirname(settingsPath(loc)), 'agents');
+}
+/**
+ * Rewrite Claude Code's `mcp__specship__<tool>` names in prose to the bare
+ * name the Gemini model is shown (DOM-SPECSHIP-007), so the skill and agent
+ * bodies name tools the way Gemini does.
+ */
+/**
+ * Render one shipped skill file for Gemini (SKILL.md format is shared),
+ * through the same rewrites as the commands (REQ-AGENTSWITCH-014): Gemini's
+ * tool names, `gemini mcp add`, and Gemini's memory file.
+ */
+function renderGeminiSkillFile(name) {
+    return (0, gemini_commands_1.rewriteForGemini)(fs.readFileSync((0, shared_1.packageAssetPath)('skills', name), 'utf-8'), { skills: shippedSkillRoots() });
+}
+/** Write `content` to `dest` with the installer's idempotency contract. */
+function writeIfChanged(dest, content) {
+    const existed = fs.existsSync(dest);
+    if (existed && fs.readFileSync(dest, 'utf-8') === content)
+        return { path: dest, action: 'unchanged' };
+    (0, shared_1.atomicWriteFileSync)(dest, content);
+    return { path: dest, action: existed ? 'updated' : 'created' };
+}
+/**
+ * Write SpecShip's skills (`spec-author`, `design-md`) under Gemini's skills
+ * dir (REQ-AGENTSWITCH-005.A1). Same file list as the Claude target, so the
+ * two installs cannot diverge. Sibling user skills are never touched.
+ */
+/** Marks a skill directory as written by SpecShip, so install and uninstall touch only their own. */
+exports.GEMINI_SKILL_MARKER_FILE = '.specship-installed';
+/** The top-level skill directories we ship (`spec-author`, `design-md`). */
+function shippedSkillRoots() {
+    return [...new Set(claude_1.SHIPPED_SKILLS.map((f) => f.split('/')[0]))];
+}
+/**
+ * A skill directory is SpecShip's to write when it does not exist yet, already
+ * carries our marker, or holds no SKILL.md (an empty leftover). A directory a
+ * user authored — a SKILL.md and no marker — is theirs and is never touched.
+ */
+function ownsSkillDir(skillDir) {
+    if (!fs.existsSync(skillDir))
+        return true;
+    if (fs.existsSync(path.join(skillDir, exports.GEMINI_SKILL_MARKER_FILE)))
+        return true;
+    return !fs.existsSync(path.join(skillDir, 'SKILL.md'));
+}
+function writeGeminiSkillsEntries(loc) {
+    const dir = geminiSkillsDir(loc);
+    const files = [];
+    for (const root of shippedSkillRoots()) {
+        const skillDir = path.join(dir, root);
+        const ours = claude_1.SHIPPED_SKILLS.filter((f) => f.startsWith(root + '/'));
+        if (!ownsSkillDir(skillDir)) {
+            for (const f of ours)
+                files.push({ path: path.join(dir, f), action: 'kept' });
+            continue;
+        }
+        for (const f of ours)
+            files.push(writeIfChanged(path.join(dir, f), renderGeminiSkillFile(f)));
+        writeIfChanged(path.join(skillDir, exports.GEMINI_SKILL_MARKER_FILE), 'Written by specship install (REQ-AGENTSWITCH-005).\n');
+    }
+    return files;
+}
+/**
+ * Inverse of `writeGeminiSkillsEntries`: delete exactly the files we ship,
+ * then prune the per-skill directories left empty. A user skill — or a user
+ * file inside one of our skill dirs — survives.
+ */
+function removeGeminiSkillsEntries(loc) {
+    const dir = geminiSkillsDir(loc);
+    const files = [];
+    for (const root of shippedSkillRoots()) {
+        const skillDir = path.join(dir, root);
+        const marker = path.join(skillDir, exports.GEMINI_SKILL_MARKER_FILE);
+        const ours = claude_1.SHIPPED_SKILLS.filter((f) => f.startsWith(root + '/'));
+        // Only a directory SpecShip marked is removed; a user's own skill stays.
+        if (!fs.existsSync(marker)) {
+            for (const f of ours) {
+                const dest = path.join(dir, f);
+                files.push({ path: dest, action: fs.existsSync(dest) ? 'kept' : 'not-found' });
+            }
+            continue;
+        }
+        for (const f of ours) {
+            const dest = path.join(dir, f);
+            if (!fs.existsSync(dest)) {
+                files.push({ path: dest, action: 'not-found' });
+                continue;
+            }
+            (0, shared_1.removeFileSync)(dest);
+            files.push({ path: dest, action: 'removed' });
+        }
+        (0, shared_1.removeFileSync)(marker);
+    }
+    (0, shared_1.pruneEmptySkillDirs)(dir, claude_1.SHIPPED_SKILLS);
+    return files;
+}
+/** Body marker identifying an agent file a SpecShip install wrote. */
+exports.GEMINI_AGENT_MARKER = '<!-- Written by specship install — REQ-AGENTSWITCH-005 -->';
+const GEMINI_AGENT_FILE = 'specship-explorer.md';
+/**
+ * Render the shipped `agents/specship-explorer.md` as a Gemini subagent
+ * (REQ-AGENTSWITCH-005.A2). Frontmatter is rebuilt with only keys Gemini's
+ * strict schema accepts — `model: inherit` is dropped (Gemini would read it as
+ * a model id) — and `tools` becomes a YAML array of the installed Gemini CLI's
+ * MCP tool names (REQ-AGENTSWITCH-018).
+ * The body names tools by their bare Gemini name. No `mcp__specship__` survives.
+ */
+function renderGeminiExplorerAgent(source) {
+    const raw = source ?? fs.readFileSync((0, shared_1.packageAssetPath)('agents', GEMINI_AGENT_FILE), 'utf-8');
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (!m)
+        throw new Error('specship-explorer agent asset has no frontmatter');
+    const front = m[1];
+    const body = m[2];
+    const field = (key) => {
+        const line = front.split(/\r?\n/).find((l) => l.startsWith(`${key}:`));
+        return line?.slice(key.length + 1).trim();
+    };
+    const name = field('name') ?? 'specship-explorer';
+    const description = field('description') ?? '';
+    const tools = (field('tools') ?? '')
+        .split(',')
+        .map((t) => t.trim())
+        .filter(Boolean)
+        .map((t) => (0, gemini_version_1.geminiMcpToolName)('specship', t.replace(/^mcp__specship__/, ''), (0, gemini_version_1.probeGeminiVersion)()));
+    return [
+        '---',
+        `name: ${name}`,
+        // JSON string = valid YAML double-quoted scalar; the description carries
+        // quotes and dashes a plain scalar would mis-parse.
+        `description: ${JSON.stringify(description)}`,
+        'tools:',
+        ...tools.map((t) => `  - ${t}`),
+        '---',
+        exports.GEMINI_AGENT_MARKER,
+        '',
+        (0, gemini_commands_1.rewriteForGemini)(body, { skills: shippedSkillRoots() }).replace(/^\s+/, ''),
+    ].join('\n');
+}
+/** Write the explorer subagent under Gemini's agents dir. Never overwrites a user file. */
+function writeGeminiAgentsEntry(loc) {
+    const dest = path.join(geminiAgentsDir(loc), GEMINI_AGENT_FILE);
+    const content = renderGeminiExplorerAgent();
+    if (fs.existsSync(dest)) {
+        const current = fs.readFileSync(dest, 'utf-8');
+        if (current === content)
+            return { path: dest, action: 'unchanged' };
+        if (!current.includes(exports.GEMINI_AGENT_MARKER))
+            return { path: dest, action: 'kept' };
+        (0, shared_1.atomicWriteFileSync)(dest, content);
+        return { path: dest, action: 'updated' };
+    }
+    (0, shared_1.atomicWriteFileSync)(dest, content);
+    return { path: dest, action: 'created' };
+}
+/** Inverse of `writeGeminiAgentsEntry`: removes the file only if it carries our marker. */
+function removeGeminiAgentsEntry(loc) {
+    const dest = path.join(geminiAgentsDir(loc), GEMINI_AGENT_FILE);
+    if (!fs.existsSync(dest))
+        return { path: dest, action: 'not-found' };
+    if (!fs.readFileSync(dest, 'utf-8').includes(exports.GEMINI_AGENT_MARKER))
+        return { path: dest, action: 'kept' };
+    (0, shared_1.removeFileSync)(dest);
+    return { path: dest, action: 'removed' };
+}
+const AGENTS_EXPERIMENTAL_NOTE = 'Gemini CLI: installed the specship-explorer subagent, but Gemini subagents are ' +
+    'experimental and off by default — set experimental.enableAgents to true in ' +
+    'Gemini settings to use it (SpecShip does not change that setting).';
+function foundLabel(version) {
+    return version ? `found ${version}` : 'Gemini CLI version not found';
+}
 class GeminiCliTarget {
     id = 'gemini';
-    displayName = 'Gemini CLI';
+    traits = hook_output_1.GEMINI_CLI_TRAITS;
+    displayName = hook_output_1.GEMINI_CLI_TRAITS.displayName;
+    recentProjects(home) {
+        return (0, gemini_projects_1.geminiRecentProjects)(home);
+    }
+    switchNote = exports.GEMINI_FOLDER_TRUST_NOTE;
     docsUrl = 'https://google-gemini.github.io/gemini-cli/docs/cli/configuration.html';
     supportsLocation(_loc) {
         return true;
@@ -594,11 +904,13 @@ class GeminiCliTarget {
     }
     /**
      * Writes the MCP entry, GEMINI.md steering, hooks, the rendered slash
-     * commands and (with `--trust`) the policy TOML. `autoAllow` and
+     * commands and (with `trust`) the policy TOML. `autoAllow` and
      * `installStatusLine` are accepted and IGNORED — Gemini CLI has no
-     * permissions list or status line to write them to, and faking one would be
-     * worse than the note (REQ-GEMINI-006). Nothing under `.claude/` is ever
-     * touched (REQ-GEMINI-006.A2).
+     * permissions list or status line to write them to; auto-allow arrives as
+     * `trust` (from `--trust`, or a switch carrying a Claude install's
+     * auto-allow over, REQ-AGENTSWITCH-010.A3), and the status line is named
+     * as unavailable in the notes (REQ-GEMINI-006, REQ-AGENTSWITCH-010.A4).
+     * Nothing under `.claude/` is ever touched (REQ-GEMINI-006.A2).
      */
     install(loc, opts) {
         const integrations = [
@@ -606,6 +918,16 @@ class GeminiCliTarget {
             ...(opts.withDesigner ? ['designer'] : []),
         ];
         const files = [writeGeminiMcpEntry(loc, integrations)];
+        // REQ-AGENTSWITCH-009: Gemini reads the user's CLAUDE.md in place (never
+        // copied). Remember the names we added so uninstall removes only those;
+        // names an earlier install added stay remembered across a re-run.
+        const contextFiles = writeGeminiContextFilesEntry(loc);
+        if (contextFiles.file)
+            files.push(contextFiles.file);
+        if (contextFiles.added.length > 0) {
+            const prior = (0, agent_record_1.readAddedContextFiles)(this.id, loc, recordRoot(loc)) ?? [];
+            (0, agent_record_1.setAddedContextFiles)(this.id, loc, recordRoot(loc), [...new Set([...prior, ...contextFiles.added])]);
+        }
         // GEMINI.md retrieval preference — always written (REQ-GEMINI-004).
         files.push(writeGeminiInstructionsEntry(loc));
         // SDD rule — default-on, matching the Claude target's governance tier.
@@ -620,18 +942,40 @@ class GeminiCliTarget {
         files.push(includeGovernance ? writeGeminiSddHooksEntry(loc) : removeGeminiSddHooksEntry(loc));
         // Slash commands (REQ-GEMINI-005), rendered from the Claude sources.
         // Same tiering as the Claude target: governance doors ride `--sdd`.
-        const commands = writeGeminiCommandsEntries(loc, includeGovernance);
+        // The version gate comes first: commands keep references to the skills
+        // this install provides (REQ-AGENTSWITCH-014.A2).
+        const version = (0, gemini_version_1.probeGeminiVersion)();
+        const skillsSupported = (0, gemini_version_1.geminiVersionSupports)(version, exports.GEMINI_MIN_SKILLS);
+        const commands = writeGeminiCommandsEntries(loc, includeGovernance, undefined, skillsSupported ? shippedSkillRoots() : []);
         files.push(...commands.files);
         // REQ-GEMINI-009: strictly opt-in. Omitting `--trust` NEVER touches the
         // policy file — a prior `--trust` install is preserved byte-identical
         // (parity with REQ-INTEG-001.A3).
-        const notes = [CAPABILITY_NOTE, ...commands.notes];
+        // REQ-AGENTSWITCH-010.A4: every feature Gemini has no surface for is
+        // named on its own line (from GEMINI_PARITY), never dropped silently.
+        const notes = [CAPABILITY_NOTE, ...(0, feature_parity_1.noSurfaceNotes)(), ...commands.notes];
+        // Skills + explorer subagent (REQ-AGENTSWITCH-005), gated on the installed
+        // Gemini CLI version. An unknown or older version is skipped WITH a note —
+        // never guessed, never fatal (the install still exits 0).
+        if (skillsSupported) {
+            files.push(...writeGeminiSkillsEntries(loc));
+        }
+        else {
+            notes.push(`Gemini CLI: skipped skills spec-author, design-md — needs Gemini CLI >= ${exports.GEMINI_MIN_SKILLS} (${foundLabel(version)}).`);
+        }
+        if ((0, gemini_version_1.geminiVersionSupports)(version, exports.GEMINI_MIN_AGENTS)) {
+            files.push(writeGeminiAgentsEntry(loc));
+            if (!(0, gemini_version_1.geminiVersionSupports)(version, exports.GEMINI_AGENTS_ON_BY_DEFAULT))
+                notes.push(AGENTS_EXPERIMENTAL_NOTE);
+        }
+        else {
+            notes.push(`Gemini CLI: skipped subagent specship-explorer — needs Gemini CLI >= ${exports.GEMINI_MIN_AGENTS} (${foundLabel(version)}).`);
+        }
         if (opts.trust === true) {
             files.push(writeGeminiPolicyEntry());
             notes.push(TRUST_POLICY_NOTE);
         }
-        if (loc === 'local')
-            notes.push(LOCAL_TRUST_NOTE);
+        notes.push(exports.GEMINI_FOLDER_TRUST_NOTE);
         return { files, notes };
     }
     /**
@@ -654,6 +998,10 @@ class GeminiCliTarget {
             (0, shared_1.writeJsonFile)(file, config);
             files.push({ path: file, action: 'removed' });
         }
+        // REQ-AGENTSWITCH-009.A4: drop only the context file names we added.
+        const contextCleanup = removeGeminiContextFilesEntry(loc, (0, agent_record_1.readAddedContextFiles)(this.id, loc, recordRoot(loc)));
+        if (contextCleanup)
+            files.push(contextCleanup);
         // Hooks (REQ-GEMINI-010.A4) — strip both tiers so uninstall reverses
         // either install path. Each helper is surgical: user-written sibling
         // hooks survive byte-identical.
@@ -678,6 +1026,12 @@ class GeminiCliTarget {
         const policyCleanup = removeGeminiPolicyEntry();
         if (policyCleanup.action !== 'not-found')
             files.push(policyCleanup);
+        // REQ-AGENTSWITCH-005: always strip skills + subagent, whatever version is
+        // installed now, so uninstall reverses any earlier install.
+        files.push(...removeGeminiSkillsEntries(loc).filter((f) => f.action === 'removed'));
+        const agentCleanup = removeGeminiAgentsEntry(loc);
+        if (agentCleanup.action !== 'not-found')
+            files.push(agentCleanup);
         return { files };
     }
     /**
@@ -688,6 +1042,11 @@ class GeminiCliTarget {
         const snippet = JSON.stringify({ mcpServers: { specship: geminiEntry() } }, null, 2);
         return `# Add to ${settingsPath(loc)}\n\n${snippet}\n`;
     }
+    locationHint(loc) {
+        const first = this.describePaths(loc)[0] ?? '';
+        const home = os.homedir();
+        return first.startsWith(home + path.sep) ? '~' + first.slice(home.length) : first;
+    }
     describePaths(loc) {
         return [settingsPath(loc), geminiMdPath(loc), geminiCommandsDir(loc)];
     }