@specship/specship-win32-arm64 0.25.0 → 0.28.0

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

@@ -2,14 +2,15 @@
 /**
  * Google Gemini CLI target — Phase 1 (GEMINI-TARGET-DOC, REQ-GEMINI-002/003).
  *
- * Implements the full `AgentTarget` contract over exactly ONE surface:
- * Gemini CLI's `mcpServers` settings block. Everything the Claude target
- * additionally writes (permissions, auto-sync + steering hooks, slash
- * commands, the `specship-explorer` subagent, the status line, the CLAUDE.md
- * steering block) has no Gemini equivalent, so `install` writes none of it and
- * says so in `notes` rather than half-installing it (REQ-GEMINI-006).
- * GEMINI.md steering (REQ-GEMINI-004) and TOML commands (REQ-GEMINI-005) are
- * still unimplemented — deliberately absent, not faked.
+ * Implements the full `AgentTarget` contract over Gemini CLI's `mcpServers`
+ * settings block, GEMINI.md steering (REQ-GEMINI-004), settings hooks
+ * (REQ-GEMINI-010/011), the opt-in `--trust` policy (REQ-GEMINI-009) and the
+ * 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
+ * named in `notes` rather than half-installed (REQ-GEMINI-006).
  *
  * The target IS registered in `targets/registry.ts`, but a plain
  * `specship install` stays Claude-only: target selection is opt-in through
@@ -66,17 +67,77 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.geminiTarget = exports.GeminiCliTarget = void 0;
 exports.settingsPath = settingsPath;
+exports.writeGeminiInstructionsEntry = writeGeminiInstructionsEntry;
+exports.removeGeminiInstructionsEntry = removeGeminiInstructionsEntry;
+exports.writeGeminiSddEntry = writeGeminiSddEntry;
+exports.removeGeminiSddEntry = removeGeminiSddEntry;
 exports.writeGeminiMcpEntry = writeGeminiMcpEntry;
+exports.geminiCommandsDir = geminiCommandsDir;
+exports.writeGeminiCommandsEntries = writeGeminiCommandsEntries;
+exports.removeGeminiCommandsEntries = removeGeminiCommandsEntries;
+exports.writeGeminiHooksEntry = writeGeminiHooksEntry;
+exports.writeGeminiSddHooksEntry = writeGeminiSddHooksEntry;
+exports.removeGeminiHooksEntry = removeGeminiHooksEntry;
+exports.removeGeminiSddHooksEntry = removeGeminiSddHooksEntry;
+exports.renderGeminiPolicyToml = renderGeminiPolicyToml;
+exports.writeGeminiPolicyEntry = writeGeminiPolicyEntry;
+exports.removeGeminiPolicyEntry = removeGeminiPolicyEntry;
 const fs = __importStar(require("fs"));
 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");
 /** Gemini CLI's settings file for this location. */
 function settingsPath(loc) {
     return loc === 'global'
         ? path.join(os.homedir(), '.gemini', 'settings.json')
         : path.join(process.cwd(), '.gemini', 'settings.json');
 }
+/**
+ * Gemini CLI's project / user context file. Global → `~/.gemini/GEMINI.md`
+ * (user memory, loaded in every session); local → `<cwd>/GEMINI.md` (project
+ * memory, loaded when Gemini CLI starts in this repo). Mirror of the Claude
+ * target's `claudeMdPath` for CLAUDE.md.
+ */
+function geminiMdPath(loc) {
+    return loc === 'global'
+        ? path.join(os.homedir(), '.gemini', 'GEMINI.md')
+        : path.join(process.cwd(), 'GEMINI.md');
+}
+/**
+ * Write the retrieval-preference block into GEMINI.md (REQ-GEMINI-004).
+ * Marker-delimited and idempotent — content outside the markers is never
+ * touched, and a byte-identical re-run returns `unchanged`.
+ */
+function writeGeminiInstructionsEntry(loc) {
+    const file = geminiMdPath(loc);
+    const action = (0, shared_1.upsertMarkedSection)(file, instructions_template_1.SPECSHIP_GEMINI_RETRIEVAL_START, instructions_template_1.SPECSHIP_GEMINI_RETRIEVAL_END, (0, instructions_template_1.getGeminiRetrievalBlock)());
+    return { path: file, action };
+}
+/** Inverse of `writeGeminiInstructionsEntry`: strip the retrieval block. */
+function removeGeminiInstructionsEntry(loc) {
+    const file = geminiMdPath(loc);
+    const action = (0, shared_1.removeMarkedSection)(file, instructions_template_1.SPECSHIP_GEMINI_RETRIEVAL_START, instructions_template_1.SPECSHIP_GEMINI_RETRIEVAL_END);
+    return { path: file, action };
+}
+/**
+ * Write the spec-driven-development steering block into GEMINI.md
+ * (REQ-GEMINI-004.A4). Generated from the SAME `getSddRuleBlock` the Claude
+ * target writes, so the two surfaces cannot drift byte-wise.
+ */
+function writeGeminiSddEntry(loc) {
+    const file = geminiMdPath(loc);
+    const action = (0, shared_1.upsertMarkedSection)(file, instructions_template_1.SPECSHIP_SDD_SECTION_START, instructions_template_1.SPECSHIP_SDD_SECTION_END, (0, instructions_template_1.getSddRuleBlock)());
+    return { path: file, action };
+}
+/** Inverse of `writeGeminiSddEntry`: strip the SDD rule block. */
+function removeGeminiSddEntry(loc) {
+    const file = geminiMdPath(loc);
+    const action = (0, shared_1.removeMarkedSection)(file, instructions_template_1.SPECSHIP_SDD_SECTION_START, instructions_template_1.SPECSHIP_SDD_SECTION_END);
+    return { path: file, action };
+}
 /**
  * The `mcpServers.specship` entry as Gemini CLI wants it: the Claude entry
  * minus `type`, which Gemini restricts to `'sse' | 'http'` (a stdio server is
@@ -86,7 +147,15 @@ function settingsPath(loc) {
  */
 function geminiEntry(integrations = []) {
     const { type: _stdioIsImplied, ...server } = (0, shared_1.getMcpServerConfig)(integrations);
-    return server;
+    // Host marker (REQ-LOWEND-001): tier auto-detection's Gemini leg only runs
+    // when the server was launched by Gemini CLI. This env is that evidence —
+    // present in both the written entry and the printable snippet by
+    // construction, absent from every Claude Code launch.
+    const env = {
+        ...server.env,
+        SPECSHIP_HOST: 'gemini',
+    };
+    return { ...server, env };
 }
 /**
  * Write the specship server into Gemini CLI's `mcpServers` block
@@ -120,13 +189,388 @@ function writeGeminiMcpEntry(loc, integrations = []) {
 }
 /**
  * What a Claude install provides that this one does not (REQ-GEMINI-006.A1).
- * One note, naming every unsupported surface, so the gap is explicit at
- * install time instead of discovered as a missing feature later.
+ * 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`.
  */
-const CAPABILITY_NOTE = 'Gemini CLI install wires the MCP server only. No auto-sync/steering hooks, ' +
-    'no slash commands, no specship-explorer subagent, no status line, and no ' +
-    'permissions auto-allow — Gemini CLI has no equivalent surface. Retrieval ' +
-    'steering therefore relies solely on the MCP server instructions.';
+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 ' +
+    'itself still lives in the MCP server instructions.';
+/**
+ * Gemini CLI's custom-commands dir for this location (verified against
+ * gemini-cli 0.28.0 `Storage.getUserCommandsDir` / `getProjectCommandsDir`):
+ * global `~/.gemini/commands`, local `<cwd>/.gemini/commands`. Same scope as
+ * the MCP entry written by `settingsPath`.
+ */
+function geminiCommandsDir(loc) {
+    return path.join(path.dirname(settingsPath(loc)), 'commands');
+}
+/**
+ * Every command the Claude installer ships, both tiers — the Gemini set is
+ * derived from the same list so the surfaces can't diverge (REQ-GEMINI-005).
+ */
+const ALL_COMMAND_SOURCES = [
+    ...claude_1.RETRIEVAL_TIER_COMMANDS,
+    ...claude_1.GOVERNANCE_TIER_COMMANDS,
+];
+/** True when `file` is a TOML a SpecShip install wrote (carries our header). */
+function isOurCommandFile(file) {
+    try {
+        return fs.readFileSync(file, 'utf-8').startsWith(gemini_commands_1.GEMINI_COMMAND_HEADER_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Render and write the slash commands (REQ-GEMINI-005). Same tiering as the
+ * Claude target: the retrieval door always, the governance doors unless
+ * `--no-sdd`. Per-file idempotent (byte-equal → `unchanged`); a user-authored
+ * file at one of our paths (no header marker) is never overwritten (`kept`).
+ * A command the renderer excluded is NOT written, a stale copy an earlier
+ * install wrote is removed, and the exclusion is returned as a note.
+ *
+ * `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')) {
+    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)) {
+        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);
+                files.push({ path: dest, action: 'removed' });
+            }
+            continue;
+        }
+        const existed = fs.existsSync(dest);
+        if (existed) {
+            const current = fs.readFileSync(dest, 'utf-8');
+            if (current === cmd.toml) {
+                files.push({ path: dest, action: 'unchanged' });
+                continue;
+            }
+            if (!current.startsWith(gemini_commands_1.GEMINI_COMMAND_HEADER_MARKER)) {
+                files.push({ path: dest, action: 'kept' });
+                continue;
+            }
+        }
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, cmd.toml);
+        files.push({ path: dest, action: existed ? 'updated' : 'created' });
+    }
+    return { files, notes };
+}
+/**
+ * Inverse of `writeGeminiCommandsEntries` (REQ-GEMINI-005.A2). Removes only
+ * files at our command paths that carry our header marker — user-authored
+ * commands, in the same `specship/` subdir or anywhere else in the commands
+ * dir, survive byte-identical. The `specship/` subdir is dropped only when
+ * that leaves it empty.
+ */
+function removeGeminiCommandsEntries(loc) {
+    const dir = geminiCommandsDir(loc);
+    const files = [];
+    for (const source of ALL_COMMAND_SOURCES) {
+        const dest = path.join(dir, (0, gemini_commands_1.geminiCommandTarget)(source));
+        if (!fs.existsSync(dest))
+            continue;
+        if (!isOurCommandFile(dest)) {
+            files.push({ path: dest, action: 'kept' });
+            continue;
+        }
+        fs.unlinkSync(dest);
+        files.push({ path: dest, action: 'removed' });
+    }
+    const parents = new Set(ALL_COMMAND_SOURCES.map((s) => path.dirname(path.join(dir, s))));
+    for (const parent of parents) {
+        try {
+            if (parent !== dir && fs.existsSync(parent) && fs.readdirSync(parent).length === 0) {
+                fs.rmdirSync(parent);
+            }
+        }
+        catch {
+            // Leave the directory in place if it can't be removed — never fatal.
+        }
+    }
+    return files;
+}
+/**
+ * Opt-in `--trust` only (REQ-GEMINI-009.A5): shown alongside the policy
+ * writer so a user who opted in knows the limits of what the file does.
+ */
+const TRUST_POLICY_NOTE = 'Wrote ~/.gemini/policies/specship.toml allowing SpecShip\'s read-only ' +
+    '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.
+ */
+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.';
+const GEMINI_HOOKS = [
+    // Prompt-level retrieval nudge — mirror of Claude's UserPromptSubmit.
+    {
+        event: 'BeforeAgent',
+        matcher: '',
+        hook: { type: 'command', command: 'specship steer-nudge' },
+    },
+    // SessionStart cheat-sheet (human-facing, systemMessage).
+    {
+        event: 'SessionStart',
+        matcher: '',
+        hook: { type: 'command', command: 'specship cheatsheet' },
+    },
+    // SessionStart sync + drift summary — one-shot catch-up at session start.
+    {
+        event: 'SessionStart',
+        matcher: '',
+        hook: { type: 'command', command: 'specship sync --quiet --drift-summary' },
+    },
+    // Post-edit sync — Gemini's `write_file` / `replace` tools are the write
+    // surface, so matcher is scoped there (parity with Claude's Edit|Write).
+    {
+        event: 'AfterTool',
+        matcher: 'write_file|replace',
+        hook: { type: 'command', command: 'specship sync --quiet' },
+    },
+    // Search-intercept — REQ-GEMINI-011. Advisory redirect on built-in
+    // grep_search / glob, plus run_shell_command (which gets classified
+    // search-vs-other at hook time; non-search shell commands pass through
+    // silently). In strict mode (`SPECSHIP_GEMINI_STRICT=1`) grep_search and
+    // glob are denied; run_shell_command NEVER denies.
+    {
+        event: 'BeforeTool',
+        matcher: 'grep_search',
+        hook: { type: 'command', command: 'specship search-intercept' },
+    },
+    {
+        event: 'BeforeTool',
+        matcher: 'glob',
+        hook: { type: 'command', command: 'specship search-intercept' },
+    },
+    {
+        event: 'BeforeTool',
+        matcher: 'run_shell_command',
+        hook: { type: 'command', command: 'specship search-intercept' },
+    },
+];
+/** SDD governance tier — opt-out via `--no-sdd`, matching the Claude install. */
+const GEMINI_SDD_HOOKS = [
+    {
+        event: 'BeforeAgent',
+        matcher: '',
+        hook: { type: 'command', command: 'specship spec-nudge' },
+    },
+];
+/**
+ * Idempotently merge Gemini hook entries into `settings.hooks`. Mirrors the
+ * Claude target's `writeHooksFor`: a matcher group sharing our exact matcher
+ * string is reused, sibling matchers / events are untouched, a byte-equal
+ * command is skipped. Returns `unchanged` when nothing was added.
+ */
+function writeGeminiHooksFor(loc, hooks) {
+    const file = settingsPath(loc);
+    const created = !fs.existsSync(file);
+    const settings = (0, shared_1.readJsonFile)(file);
+    const beforeJson = JSON.stringify(settings);
+    if (!settings.hooks || typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+        settings.hooks = {};
+    }
+    for (const { event, matcher, hook } of hooks) {
+        if (!Array.isArray(settings.hooks[event]))
+            settings.hooks[event] = [];
+        let group = settings.hooks[event].find((g) => g && g.matcher === matcher);
+        if (!group) {
+            group = { matcher, hooks: [] };
+            settings.hooks[event].push(group);
+        }
+        if (!Array.isArray(group.hooks))
+            group.hooks = [];
+        if (!group.hooks.some((h) => h && h.command === hook.command)) {
+            group.hooks.push({ ...hook });
+        }
+    }
+    const afterJson = JSON.stringify(settings);
+    if (beforeJson === afterJson && !created) {
+        return { path: file, action: 'unchanged' };
+    }
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: created ? 'created' : 'updated' };
+}
+/**
+ * Surgically remove a predicate-matched set of commands from `settings.hooks`,
+ * then prune empty matcher groups / events / the top-level `hooks` map.
+ * Mirrors Claude's `stripHooksMatching` so sibling user-written hooks survive
+ * byte-identical.
+ */
+function stripGeminiHooksMatching(loc, predicate) {
+    const file = settingsPath(loc);
+    if (!fs.existsSync(file))
+        return { path: file, action: 'not-found' };
+    const settings = (0, shared_1.readJsonFile)(file);
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+        return { path: file, action: 'unchanged' };
+    }
+    let removedAny = false;
+    for (const event of Object.keys(hooks)) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        for (const group of groups) {
+            if (!group || !Array.isArray(group.hooks))
+                continue;
+            const before = group.hooks.length;
+            group.hooks = group.hooks.filter((h) => !predicate(h?.command));
+            if (group.hooks.length !== before)
+                removedAny = true;
+        }
+    }
+    if (!removedAny)
+        return { path: file, action: 'unchanged' };
+    for (const event of Object.keys(hooks)) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        hooks[event] = groups.filter((g) => !(g && Array.isArray(g.hooks) && g.hooks.length === 0));
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    if (Object.keys(hooks).length === 0)
+        delete settings.hooks;
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: 'removed' };
+}
+/** Write the default (retrieval + sync + cheatsheet) hook set. */
+function writeGeminiHooksEntry(loc) {
+    return writeGeminiHooksFor(loc, GEMINI_HOOKS);
+}
+/** Write the governance-tier SDD nudge hook. */
+function writeGeminiSddHooksEntry(loc) {
+    return writeGeminiHooksFor(loc, GEMINI_SDD_HOOKS);
+}
+function isGeminiHookCommand(command) {
+    if (typeof command !== 'string')
+        return false;
+    return GEMINI_HOOKS.some(({ hook }) => command === hook.command);
+}
+function isGeminiSddHookCommand(command) {
+    if (typeof command !== 'string')
+        return false;
+    return GEMINI_SDD_HOOKS.some(({ hook }) => command === hook.command);
+}
+/** Inverse of `writeGeminiHooksEntry`. */
+function removeGeminiHooksEntry(loc) {
+    return stripGeminiHooksMatching(loc, isGeminiHookCommand);
+}
+/** Inverse of `writeGeminiSddHooksEntry`. */
+function removeGeminiSddHooksEntry(loc) {
+    return stripGeminiHooksMatching(loc, isGeminiSddHookCommand);
+}
+/**
+ * Policy TOML (REQ-GEMINI-009): auto-allow Gemini's per-tool confirmation
+ * for SpecShip's READ-ONLY MCP tools only. User tier by construction — we
+ * never write to the admin policies directory, and an admin rule still wins
+ * over this one (that is the intended outcome). `run_shell_command` is out
+ * of scope: this file removes prompts only for SpecShip's own tools.
+ *
+ * Verified against Gemini CLI 0.28.0 `loadPoliciesFromToml`: the loader
+ * composes `specship__<toolName>` from `mcpName` itself, so every entry here
+ * is the BARE server tool name — a prefixed name would match nothing.
+ */
+function geminiPolicyPath() {
+    return path.join(os.homedir(), '.gemini', 'policies', 'specship.toml');
+}
+const GEMINI_POLICY_HEADER_MARKER = '# Written by specship install --trust — REQ-GEMINI-009';
+const READONLY_TOOLS = Object.freeze([
+    'specship_explore',
+    'specship_search',
+    'specship_node',
+    'specship_callers',
+    'specship_callees',
+    'specship_impact',
+    'specship_files',
+    'specship_status',
+    'specship_health',
+    'specship_spec',
+    'specship_drifted',
+]);
+/** Mid of Gemini's 0–999 priority range: well below admin tiers. */
+const POLICY_PRIORITY = 100;
+/**
+ * Pure string builder for `specship.toml`. Single source for the writer so
+ * the on-disk content and any future `printConfig` surface cannot drift.
+ */
+function renderGeminiPolicyToml() {
+    const toolList = READONLY_TOOLS.map((t) => `"${t}"`).join(', ');
+    return [
+        GEMINI_POLICY_HEADER_MARKER,
+        '# User-tier policy auto-allowing SpecShip\'s read-only MCP tools.',
+        '# An administrator policy overrides this file. Shell-command',
+        '# confirmations (run_shell_command) are not affected.',
+        '',
+        // Gemini's loader reads `[[rule]]` tables (0.28.0 PolicyFileSchema.rule);
+        // any other table name is silently ignored and the policy does nothing.
+        '[[rule]]',
+        'mcpName = "specship"',
+        `toolName = [${toolList}]`,
+        'decision = "allow"',
+        `priority = ${POLICY_PRIORITY}`,
+        '',
+    ].join('\n');
+}
+/**
+ * Write `~/.gemini/policies/specship.toml`. Idempotent — byte-identical
+ * contents report `unchanged`. Never touches the admin policies directory.
+ */
+function writeGeminiPolicyEntry() {
+    const file = geminiPolicyPath();
+    const content = renderGeminiPolicyToml();
+    const existed = fs.existsSync(file);
+    if (existed) {
+        const current = fs.readFileSync(file, 'utf-8');
+        if (current === content)
+            return { path: file, action: 'unchanged' };
+        // Never overwrite a user-authored file of the same name — only one that
+        // an earlier `--trust` install wrote (it carries our header marker).
+        if (!current.startsWith(GEMINI_POLICY_HEADER_MARKER))
+            return { path: file, action: 'kept' };
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, content);
+    return { path: file, action: existed ? 'updated' : 'created' };
+}
+/**
+ * Inverse of `writeGeminiPolicyEntry`. Removes `specship.toml` ONLY if its
+ * contents carry our header marker — a user-authored file of the same name
+ * is left byte-identical. Sibling files in the policies directory are
+ * untouched; the admin policies dir is never written or read.
+ */
+function removeGeminiPolicyEntry() {
+    const file = geminiPolicyPath();
+    if (!fs.existsSync(file))
+        return { path: file, action: 'not-found' };
+    const current = fs.readFileSync(file, 'utf-8');
+    if (!current.startsWith(GEMINI_POLICY_HEADER_MARKER)) {
+        return { path: file, action: 'kept' };
+    }
+    fs.unlinkSync(file);
+    return { path: file, action: 'removed' };
+}
 class GeminiCliTarget {
     id = 'gemini';
     displayName = 'Gemini CLI';
@@ -149,21 +593,46 @@ class GeminiCliTarget {
         };
     }
     /**
-     * Writes exactly one thing: the MCP entry. `autoAllow`, `sdd` and
+     * Writes the MCP entry, GEMINI.md steering, hooks, the rendered slash
+     * commands and (with `--trust`) the policy TOML. `autoAllow` and
      * `installStatusLine` are accepted and IGNORED — Gemini CLI has no
-     * permissions, hooks or commands surface 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, and faking one would be
+     * worse than the note (REQ-GEMINI-006). Nothing under `.claude/` is ever
+     * touched (REQ-GEMINI-006.A2).
      */
     install(loc, opts) {
         const integrations = [
             ...(opts.withJira ? ['jira'] : []),
             ...(opts.withDesigner ? ['designer'] : []),
         ];
-        return {
-            files: [writeGeminiMcpEntry(loc, integrations)],
-            notes: [CAPABILITY_NOTE],
-        };
+        const files = [writeGeminiMcpEntry(loc, integrations)];
+        // GEMINI.md retrieval preference — always written (REQ-GEMINI-004).
+        files.push(writeGeminiInstructionsEntry(loc));
+        // SDD rule — default-on, matching the Claude target's governance tier.
+        // `--no-sdd` (opts.sdd === false) self-heals by stripping an earlier
+        // governance install.
+        const includeGovernance = opts.sdd !== false;
+        files.push(includeGovernance ? writeGeminiSddEntry(loc) : removeGeminiSddEntry(loc));
+        // Prompt / session / tool hooks (REQ-GEMINI-010). Default retrieval tier
+        // is always written; the governance SDD nudge rides `--sdd` and
+        // self-heals (strip on `--no-sdd`).
+        files.push(writeGeminiHooksEntry(loc));
+        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);
+        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];
+        if (opts.trust === true) {
+            files.push(writeGeminiPolicyEntry());
+            notes.push(TRUST_POLICY_NOTE);
+        }
+        if (loc === 'local')
+            notes.push(LOCAL_TRUST_NOTE);
+        return { files, notes };
     }
     /**
      * Removes only the `mcpServers.specship` key (REQ-GEMINI-002.A2): sibling
@@ -172,16 +641,44 @@ class GeminiCliTarget {
      * rather than throwing.
      */
     uninstall(loc) {
+        const files = [];
         const file = settingsPath(loc);
         const config = (0, shared_1.readJsonFile)(file);
         if (!config.mcpServers?.specship) {
-            return { files: [{ path: file, action: 'not-found' }] };
+            files.push({ path: file, action: 'not-found' });
+        }
+        else {
+            delete config.mcpServers.specship;
+            if (Object.keys(config.mcpServers).length === 0)
+                delete config.mcpServers;
+            (0, shared_1.writeJsonFile)(file, config);
+            files.push({ path: file, action: 'removed' });
         }
-        delete config.mcpServers.specship;
-        if (Object.keys(config.mcpServers).length === 0)
-            delete config.mcpServers;
-        (0, shared_1.writeJsonFile)(file, config);
-        return { files: [{ path: file, action: 'removed' }] };
+        // 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.
+        const hookCleanup = removeGeminiHooksEntry(loc);
+        if (hookCleanup.action === 'removed')
+            files.push(hookCleanup);
+        const sddHookCleanup = removeGeminiSddHooksEntry(loc);
+        if (sddHookCleanup.action === 'removed')
+            files.push(sddHookCleanup);
+        // Strip both GEMINI.md blocks regardless of which tier was selected on
+        // install, so uninstall fully reverses either install path
+        // (REQ-GEMINI-004.A2). `removeMarkedSection` deletes the file iff
+        // removal leaves it empty, so a user-authored GEMINI.md is preserved.
+        files.push(removeGeminiInstructionsEntry(loc));
+        files.push(removeGeminiSddEntry(loc));
+        // Slash commands (REQ-GEMINI-005.A2) — only our marked TOMLs go.
+        files.push(...removeGeminiCommandsEntries(loc));
+        // REQ-GEMINI-009.A4: strip our policy TOML iff it carries our header
+        // marker — a user-authored specship.toml of the same name is left
+        // byte-identical. Sibling files in the policies directory survive, and
+        // the admin policies dir is never written or read.
+        const policyCleanup = removeGeminiPolicyEntry();
+        if (policyCleanup.action !== 'not-found')
+            files.push(policyCleanup);
+        return { files };
     }
     /**
      * The snippet, verbatim-pasteable into `mcpServers`. Pure string building —
@@ -192,7 +689,7 @@ class GeminiCliTarget {
         return `# Add to ${settingsPath(loc)}\n\n${snippet}\n`;
     }
     describePaths(loc) {
-        return [settingsPath(loc)];
+        return [settingsPath(loc), geminiMdPath(loc), geminiCommandsDir(loc)];
     }
 }
 exports.GeminiCliTarget = GeminiCliTarget;