moicle 2.0.0 → 2.2.0

package/assets/skills/review/tdd/SKILL.md

@@ -5,17 +5,25 @@ description: Test-Driven Development workflow. Use when doing TDD, writing tests
 
 # Test-Driven Development (TDD) Workflow
 
-Red-Green-Refactor cycle: write failing test → write minimal code to pass → refactor while keeping tests green.
+Red-Green-Refactor cycle: write failing test → write minimal code to pass → refactor while green.
 
 ## When to use this skill
 
-- ✅ Implementing logic with clear input → output behavior (parsers, validators, business rules, usecases)
-- ✅ Fixing a bug — write the failing test first, then fix (regression guard)
+- ✅ Logic with clear input → output behavior (parsers, validators, business rules, usecases)
+- ✅ Fixing a bug — failing test first, then fix (regression guard)
 - ✅ Refactoring critical code where you need a safety net
 - ❌ UI prototyping / visual tweaks → manual is faster
-- ❌ Exploratory spike → use `/research:spike` (throwaway code, no tests needed)
+- ❌ Exploratory spike → use `/research:spike` (throwaway, no tests)
 - ❌ One-line config change → just change it
 
+## Read Architecture First
+
+Detect stack via `~/.claude/architecture/_shared/stack-detection.md`. Architecture doc tells you:
+- Test file location convention (`_test.go` next to source, `__tests__/`, `tests/Feature/`, etc.)
+- Test framework (Go `testing`, Jest, Pest, `flutter_test`)
+- Mocking pattern for ports
+- AAA layout convention
+
 ---
 
 ## The TDD Cycle
@@ -29,62 +37,54 @@ Red-Green-Refactor cycle: write failing test → write minimal code to pass →
               next requirement
 ```
 
-## Read Architecture First
-
-Read the stack architecture doc for:
-- Test file location convention (e.g., `_test.go` next to source, `__tests__/` for Jest)
-- Test framework (Go testing, Jest, Pest, Flutter test)
-- Mocking patterns for ports (interfaces)
-- AAA (Arrange-Act-Assert) layout
-
 ---
 
-## Phase 1: RED — Write a failing test
+## Phase 1: RED — failing test
 
-**Goal:** describe the behavior you want with a test that fails because the code doesn't exist yet.
+**Goal:** describe wanted behavior with a test that fails because the code doesn't exist yet.
 
 ### Steps
-1. Pick ONE small requirement (the smallest behavior you can verify)
-2. Write the test name as a sentence describing the behavior
-3. Arrange: set up inputs and mocks
+1. Pick ONE small requirement (smallest verifiable behavior)
+2. Name the test as a sentence describing behavior
+3. Arrange: inputs + mocks
 4. Act: call the method
-5. Assert: verify the expected output / state change / event raised
-6. Run the test — it MUST fail (compile error or assertion fail). If it passes, the test is wrong.
+5. Assert: verify output / state / interaction
+6. Run — it MUST fail (compile error or assertion fail). If it passes, the test is wrong.
 
-### Test name conventions
-- `should_<expected_behavior>_when_<condition>` (snake_case for Go/Python)
+### Test naming
+- `should_<behavior>_when_<condition>` (snake_case for Go / Python)
 - `it("returns X when Y", ...)` (Jest / Mocha)
-- `test_<behavior>_<condition>` (PHPUnit)
+- `test_<behavior>_<condition>` (PHPUnit / Pest)
 
 ### AAA pattern
 ```
 // Arrange — set up inputs and mocks
-// Act     — call the function under test
+// Act     — call function under test
 // Assert  — verify result / state / interactions
 ```
 
 ### Gate
-- [ ] Test fails for the RIGHT reason (compile error or assertion fail, not a typo)
-- [ ] Test name describes behavior, not implementation
-- [ ] Only ONE behavior tested per test
+- [ ] Test fails for the RIGHT reason (not a typo / missing import)
+- [ ] Name describes behavior, not implementation
+- [ ] One behavior per test
 
 ---
 
-## Phase 2: GREEN — Make it pass with minimal code
+## Phase 2: GREEN — minimal code to pass
 
-**Goal:** write the smallest amount of code that makes the test pass. **Resist** the urge to "do it properly" — refactor comes next.
+**Goal:** smallest amount of code to pass. **Resist** "doing it properly" — refactor is next.
 
 ### Rules
-- **Minimal** means: hardcode return values if the test allows it; you'll triangulate with more tests
+- **Minimal** means: hardcode return values if the test allows it; triangulate with more tests
 - Don't add code not required by a test
 - Don't add error handling unless a test requires it
-- Don't generalize until 3+ tests force you to
+- Don't generalize until 3+ tests force it
 
 ### Steps
-1. Run the failing test (confirm RED)
-2. Write just enough code to make it green
-3. Run all tests — all must pass (not just the new one)
-4. If other tests broke, you're not minimal — revert and try smaller
+1. Confirm RED
+2. Write just enough code to pass
+3. Run all tests — all must stay green
+4. If others broke, you're not minimal — revert + try smaller
 
 ### Gate
 - [ ] New test passes
@@ -93,31 +93,31 @@ Read the stack architecture doc for:
 
 ---
 
-## Phase 3: REFACTOR — Clean up while green
+## Phase 3: REFACTOR — clean up while green
 
-**Goal:** improve structure without changing behavior. Tests must stay green throughout.
+**Goal:** improve structure without changing behavior. Tests stay green throughout.
 
 ### What to refactor
 - **Duplication** — extract function / method / class
-- **Long methods** — split when one method does multiple things
-- **Bad names** — rename to reveal intent (most underrated refactor)
+- **Long methods** — split when one does multiple things
+- **Bad names** — rename to reveal intent (the most underrated refactor)
 - **Dead branches** — remove code no test exercises
 - **Coupling** — break dependencies that make tests painful
 
 ### Rules
-- **Run tests after every change** — green is the safety net
+- **Run tests after every change** — green is your safety net
 - **One refactor at a time** — extract method, run tests, rename, run tests, …
-- **No new behavior** — if a refactor needs a new test, you're not refactoring, go back to RED
+- **No new behavior** — if a refactor needs a new test, go back to RED
 
 ### When NOT to refactor
-- Tests are flaky — fix the flakiness first
-- You're under time pressure — skip refactor, leave a TODO with link to a follow-up task
-- The code will be deleted soon — don't polish trash
+- Tests are flaky → fix flakiness first
+- Under time pressure → skip, leave a `// TODO: refactor` linked to a follow-up
+- Code about to be deleted → don't polish trash
 
 ### Gate
 - [ ] All tests still green
 - [ ] No new public API added
-- [ ] Code is easier to read than before
+- [ ] Code easier to read than before
 
 ---
 
@@ -128,14 +128,51 @@ Read the stack architecture doc for:
 | Value Object | Unit (pure) | None | `Money.add()` |
 | Entity | Unit (pure) | None | `Order.cancel()` raises event |
 | UseCase | Unit | Mock ports | `CreateOrder` calls `OrderStore.save()` |
+| Service | Unit | Mock usecase | Delegates correctly |
 | Handler / Controller | Integration | Real router, mock service | `POST /orders` returns 201 |
 | Infrastructure | Integration | Real DB / testcontainers | `OrderRepository.save()` persists |
 | Listener | Unit | Mock infra | `on_order_created` sends email |
+| API contract (cross-service) | Contract test | Real / sandboxed external | OpenAPI / Pact / Wiremock |
+
+### Mock vs real — decision table
+
+| Dependency type | Use real | Use stub / fake | Use mock |
+|-----------------|----------|-----------------|----------|
+| Value objects, entities (pure) | ✅ always | — | never (brittle) |
+| Stdlib (time, fs, env) | mostly — use clock / fs abstraction in domain | for determinism | rarely |
+| Repository / port | testcontainers in infra tests | in-memory fake for usecase tests | only when verifying call args |
+| External HTTP API | sandbox URL in integration | wiremock / msw for predictable cases | for failure-mode tests |
+| Auth / session | real in integration | fake user in unit | rarely |
+| Time | clock abstraction | fixed clock in tests | rarely |
+
+**Stub vs fake vs mock:**
+- **Stub** — returns canned values (`returnsBalance(100)`)
+- **Fake** — working in-memory implementation (`InMemoryOrderStore`)
+- **Mock** — records calls + verifies them (`expect(store.save).toHaveBeenCalledWith(...)`)
 
-### Mock vs real
-- Mock **interfaces** (ports), not concrete classes
-- Use real value objects and entities in tests — they're pure, no need to mock
-- Use real DB in infra tests via testcontainers or in-memory variant
+Prefer **fake** for repository tests (closest to real behavior). Use **mock** only when call args are the assertion.
+
+### Property-based testing
+
+For pure logic with many edge cases (parsers, math, encoders), use property-based tests:
+
+- Go: `testing/quick`, `gopter`
+- TS / JS: `fast-check`
+- Python: `hypothesis`
+- Dart: `glados`
+
+Pattern: "for all valid input X, property P holds." Generates 100s of cases including edge cases you wouldn't think of.
+
+Example (TS, fast-check):
+```ts
+test("reverse twice = identity", () => {
+  fc.assert(fc.property(fc.array(fc.string()), (arr) => {
+    expect(reverse(reverse(arr))).toEqual(arr);
+  }));
+});
+```
+
+Use it for: serializers, parsers, math, sorting, encoding/decoding. Not for: business workflows.
 
 ---
 
@@ -143,12 +180,14 @@ Read the stack architecture doc for:
 
 | Mistake | Why it's bad | Fix |
 |---------|--------------|-----|
-| Writing tests AFTER the code | You'll test what's written, not what's needed | Always RED first |
-| Testing implementation, not behavior | Refactor breaks tests | Assert on outputs / observable state |
-| One test covers many behaviors | Fail message is unclear | One behavior per test |
-| Mocking value objects | Brittle, no real benefit | Use real ones — they're pure |
-| Skipping the REFACTOR phase | Tech debt accumulates | It's a phase, not optional |
+| Writing tests AFTER the code | Tests what's written, not what's needed | Always RED first |
+| Testing implementation, not behavior | Refactor breaks tests | Assert outputs / observable state |
+| One test, many behaviors | Failure message unclear | One behavior per test |
+| Mocking value objects | Brittle, no benefit | Use real — they're pure |
+| Skipping REFACTOR | Tech debt accumulates | It's a phase, not optional |
 | Test depends on order | Flaky | Each test sets up its own state |
+| Slow tests (>1s each) | People stop running them | Move to integration tier; keep unit <100ms |
+| 100% coverage chase | Forces tests for trivial code | Aim for high-value coverage on domain |
 
 ---
 
@@ -157,30 +196,32 @@ Read the stack architecture doc for:
 ```markdown
 ## TDD Cycle Complete: {feature}
 
-### Cycles Done
-| # | RED behavior | GREEN | REFACTOR |
-|---|-------------|-------|----------|
-| 1 | {behavior} | {code added} | {what cleaned} |
-| 2 | ... | ... | ... |
+### Cycles
+| # | RED (behavior) | GREEN (code added) | REFACTOR |
+|---|----------------|--------------------|----------|
+| 1 | rejects negative amount | guard in constructor | extracted validator |
+| 2 | transitions PENDING → ACTIVE | added transition method | — |
 
 ### Test Coverage
 - {N} tests, all passing
-- Coverage: {%} (target: ≥80% for domain layer)
+- Domain coverage: {%} (target ≥80%)
 
 ### Files
 - Tests: {paths}
-- Code: {paths}
+- Code:  {paths}
 ```
 
 ---
 
 ## Hard Rules
 
-- **RED first, always** — never write production code without a failing test driving it
-- **Minimal GREEN** — hardcode if the test allows it; triangulate later
+- **RED first, always** — no production code without a failing test driving it
+- **Minimal GREEN** — hardcode if test allows; triangulate later
 - **REFACTOR is a phase, not optional**
 - **All tests green at all times** (except briefly during RED)
 - **One behavior per test**, named after the behavior
+- **Unit tests <100ms each** — slow tests don't get run
+- **Test behavior, not implementation** — refactor must not break tests
 
 ---
 
@@ -188,19 +229,17 @@ Read the stack architecture doc for:
 
 | When | Use |
 |------|-----|
-| Building a feature from scratch (with TDD inside) | `/feature:new` + this skill |
+| Building feature from scratch (with TDD inside) | `/feature:new` + this skill |
 | Adding regression test for a bug | `/fix:hotfix` or `/fix:root-cause` → then this skill |
-| Refactoring untested legacy code (add tests first) | `refactor` |
+| Refactoring untested legacy code | `/feature:refactor` (add tests first) |
 | Reviewing test quality on a PR | `/review:pr` |
 
----
-
 ## Recommended Agents
 
 | Phase | Agent | Purpose |
 |-------|-------|---------|
-| RED | `@test-writer` | Write failing tests first |
+| RED | `@test-writer` | Failing tests first |
 | GREEN | Stack-specific dev agent | Minimal implementation |
-| REFACTOR | `@refactor` | Clean up patterns |
+| REFACTOR | `@refactor` | Patterns + cleanup |
 | REFACTOR | `@code-reviewer` | Review refactored code |
-| REFACTOR | `@perf-optimizer` | Performance tweaks (only with benchmarks) |
+| REFACTOR | `@perf-optimizer` | Perf tweaks (only with benchmarks) |

package/bin/cli.js

@@ -46,7 +46,7 @@ program
   .description('List installed agents, commands, and skills')
   .option('-g, --global', 'List global installations')
   .option('-p, --project', 'List project installations')
-  .option('-t, --target <editor>', 'Target editor (claude, codex)')
+  .option('-t, --target <editor>', 'Target editor (claude, codex, antigravity)')
   .action(listCommand);
 
 program
@@ -75,7 +75,7 @@ program
   .description('Show enabled/disabled status of all items')
   .option('-g, --global', 'Show global status')
   .option('-p, --project', 'Show project status')
-  .option('-t, --target <editor>', 'Target editor (claude, codex)')
+  .option('-t, --target <editor>', 'Target editor (claude, codex, antigravity)')
   .action(statusCommand);
 
 program

package/dist/commands/install.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/commands/install.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAmC,MAAM,aAAa,CAAC;AAyenF,eAAO,MAAM,cAAc,GAAU,SAAS,cAAc,KAAG,OAAO,CAAC,IAAI,CA0H1E,CAAC"}
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/commands/install.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAmC,MAAM,aAAa,CAAC;AAkrBnF,eAAO,MAAM,cAAc,GAAU,SAAS,cAAc,KAAG,OAAO,CAAC,IAAI,CAwI1E,CAAC"}

package/dist/commands/install.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
 import fs from 'fs';
-import { ASSETS_DIR, EDITOR_CONFIGS, isSymlinkSupported, ensureDir, createSymlink, copyFile, copyDir, getAgentsDir, getCommandsDir, getSkillsDir, getArchitectureDir, getClaudeDir, getCodexDir, getEditorDir, getEditorConfig, getFiles, getDirs, mergeAgentsToFile, } from '../utils/symlink.js';
+import { ASSETS_DIR, EDITOR_CONFIGS, isSymlinkSupported, ensureDir, createSymlink, copyFile, copyDir, getAgentsDir, getCommandsDir, getSkillsDir, getArchitectureDir, getClaudeDir, getCodexDir, getAntigravityDir, getEditorDir, getEditorConfig, getFiles, getDirs, mergeAgentsToFile, } from '../utils/symlink.js';
 import { addTarget } from '../utils/config.js';
 const printHeader = () => {
     console.log('');
@@ -133,6 +133,13 @@ const rewriteClaudePaths = (content, target) => {
     if (target === 'claude') {
         return content;
     }
+    if (target === 'antigravity') {
+        return content
+            .replace(/~\/\.claude\//g, '~/.gemini/')
+            .replace(/\.claude\//g, '.gemini/')
+            .replace(/Claude Code/g, 'Antigravity')
+            .replace(/CLAUDE\.md/g, 'GEMINI.md');
+    }
     return content
         .replace(/~\/\.claude\//g, '~/.codex/')
         .replace(/\.claude\//g, '.codex/')
@@ -297,6 +304,150 @@ const installCodexScope = async (scope) => {
     console.log('');
     console.log(chalk.green(`✓ ${label} Codex installation complete!`));
 };
+const ensureAntigravitySkillDir = (baseDir, name) => {
+    const skillDir = path.join(baseDir, name);
+    ensureDir(skillDir);
+    return skillDir;
+};
+const installAntigravitySkillFolder = (sourceDir, targetSkillsDir) => {
+    const skillName = path.basename(sourceDir);
+    const targetDir = ensureAntigravitySkillDir(targetSkillsDir, skillName);
+    const sourceFiles = getFiles(sourceDir, 8);
+    let status = 'created';
+    for (const file of sourceFiles) {
+        const relativePath = path.relative(sourceDir, file);
+        const targetFile = path.join(targetDir, relativePath);
+        ensureDir(path.dirname(targetFile));
+        const content = rewriteClaudePaths(fs.readFileSync(file, 'utf-8'), 'antigravity');
+        const existed = fs.existsSync(targetFile);
+        if (existed && fs.readFileSync(targetFile, 'utf-8') === content) {
+            status = status === 'created' ? 'exists' : status;
+            continue;
+        }
+        fs.writeFileSync(targetFile, content);
+        if (existed) {
+            status = 'updated';
+        }
+    }
+    return { status, name: skillName };
+};
+const buildGeneratedAntigravitySkill = (name, description, body) => `---
+name: ${name}
+description: ${description}
+---
+
+${body}
+`;
+const installGeneratedAntigravitySkill = (targetSkillsDir, name, description, body) => {
+    const skillDir = ensureAntigravitySkillDir(targetSkillsDir, name);
+    const targetFile = path.join(skillDir, 'SKILL.md');
+    const content = buildGeneratedAntigravitySkill(name, description, rewriteClaudePaths(body, 'antigravity'));
+    if (fs.existsSync(targetFile)) {
+        if (fs.readFileSync(targetFile, 'utf-8') === content) {
+            return { status: 'exists', name };
+        }
+        fs.writeFileSync(targetFile, content);
+        return { status: 'updated', name };
+    }
+    fs.writeFileSync(targetFile, content);
+    return { status: 'created', name };
+};
+const installDirectAntigravitySkill = (targetSkillsDir, name, content) => {
+    const skillDir = ensureAntigravitySkillDir(targetSkillsDir, name);
+    const targetFile = path.join(skillDir, 'SKILL.md');
+    const rewritten = rewriteClaudePaths(content, 'antigravity');
+    if (fs.existsSync(targetFile)) {
+        if (fs.readFileSync(targetFile, 'utf-8') === rewritten) {
+            return { status: 'exists', name };
+        }
+        fs.writeFileSync(targetFile, rewritten);
+        return { status: 'updated', name };
+    }
+    fs.writeFileSync(targetFile, rewritten);
+    return { status: 'created', name };
+};
+const installAntigravityArchitecture = (targetDir) => {
+    const results = [];
+    const archDir = path.join(ASSETS_DIR, 'architecture');
+    const targetArchDir = path.join(targetDir, 'architecture');
+    ensureDir(targetArchDir);
+    if (!fs.existsSync(archDir)) {
+        return results;
+    }
+    for (const file of getFiles(archDir)) {
+        const targetFile = path.join(targetArchDir, path.basename(file));
+        const content = rewriteClaudePaths(fs.readFileSync(file, 'utf-8'), 'antigravity');
+        if (fs.existsSync(targetFile)) {
+            if (fs.readFileSync(targetFile, 'utf-8') === content) {
+                results.push({ status: 'exists', name: path.basename(file) });
+                continue;
+            }
+            fs.writeFileSync(targetFile, content);
+            results.push({ status: 'updated', name: path.basename(file) });
+            continue;
+        }
+        fs.writeFileSync(targetFile, content);
+        results.push({ status: 'created', name: path.basename(file) });
+    }
+    return results;
+};
+const installAntigravitySkills = (targetDir) => {
+    const results = [];
+    const targetSkillsDir = path.join(targetDir, 'skills');
+    ensureDir(targetSkillsDir);
+    const skillsDir = path.join(ASSETS_DIR, 'skills');
+    if (fs.existsSync(skillsDir)) {
+        for (const dir of getDirs(skillsDir)) {
+            results.push(installAntigravitySkillFolder(dir, targetSkillsDir));
+        }
+    }
+    const commandsDir = path.join(ASSETS_DIR, 'commands');
+    if (fs.existsSync(commandsDir)) {
+        for (const file of getFiles(commandsDir)) {
+            const name = path.basename(file, '.md');
+            const content = fs.readFileSync(file, 'utf-8');
+            results.push(installDirectAntigravitySkill(targetSkillsDir, name, content));
+        }
+    }
+    const agentDirs = ['developers', 'utilities'];
+    for (const dirName of agentDirs) {
+        const sourceDir = path.join(ASSETS_DIR, 'agents', dirName);
+        if (!fs.existsSync(sourceDir)) {
+            continue;
+        }
+        for (const file of getFiles(sourceDir)) {
+            const name = path.basename(file, '.md');
+            const rawContent = fs.readFileSync(file, 'utf-8');
+            const parsed = extractFrontmatter(rawContent);
+            const description = parsed.description
+                ? parsed.description
+                : dirName === 'developers'
+                    ? `Imported MoiCle developer persona for ${name}. Use when the task matches this stack specialist.`
+                    : `Imported MoiCle utility persona for ${name}. Use when the task matches this specialist.`;
+            results.push(installGeneratedAntigravitySkill(targetSkillsDir, name, description, parsed.body.trimStart()));
+        }
+    }
+    return results;
+};
+const installAntigravityScope = async (scope) => {
+    const isGlobal = scope === 'global';
+    const label = isGlobal ? 'Global' : 'Project';
+    const targetPath = isGlobal ? '~/.gemini/' : `${process.cwd()}/.gemini/`;
+    console.log('');
+    console.log(chalk.cyan(`>>> ${label} Antigravity Installation`));
+    console.log(chalk.gray(`    Target: ${targetPath}`));
+    console.log('');
+    const antigravityDir = getAntigravityDir(scope);
+    ensureDir(antigravityDir);
+    const archResults = installAntigravityArchitecture(antigravityDir);
+    console.log(chalk.green(`  ✓ Architecture installed to ${chalk.cyan(path.join(antigravityDir, 'architecture'))}`));
+    printSummary(archResults);
+    const skillResults = installAntigravitySkills(antigravityDir);
+    console.log(chalk.green(`  ✓ Antigravity skills installed to ${chalk.cyan(path.join(antigravityDir, 'skills'))}`));
+    printSummary(skillResults);
+    console.log('');
+    console.log(chalk.green(`✓ ${label} Antigravity installation complete!`));
+};
 const showTargetMenu = async () => {
     const { target } = await inquirer.prompt([
         {
@@ -306,14 +457,15 @@ const showTargetMenu = async () => {
             choices: [
                 { name: 'Claude Code', value: 'claude' },
                 { name: 'Codex CLI', value: 'codex' },
+                { name: 'Antigravity', value: 'antigravity' },
             ],
         },
     ]);
     return target;
 };
 const showInteractiveMenu = async (target) => {
-    const globalPath = target === 'claude' ? '~/.claude/' : '~/.codex/';
-    const projectPath = target === 'claude' ? './.claude/' : './.codex/';
+    const globalPath = target === 'claude' ? '~/.claude/' : target === 'codex' ? '~/.codex/' : '~/.gemini/';
+    const projectPath = target === 'claude' ? './.claude/' : target === 'codex' ? './.codex/' : './.gemini/';
     const { installType } = await inquirer.prompt([
         {
             type: 'list',
@@ -401,7 +553,7 @@ export const installCommand = async (options) => {
     }
     for (const target of targets) {
         addTarget(target);
-        if (target === 'claude' || target === 'codex') {
+        if (target === 'claude' || target === 'codex' || target === 'antigravity') {
             let installType;
             if (options.global) {
                 installType = 'global';
@@ -420,27 +572,37 @@ export const installCommand = async (options) => {
                     if (target === 'claude') {
                         await installScope('global', useSymlink);
                     }
-                    else {
+                    else if (target === 'codex') {
                         await installCodexScope('global');
                     }
+                    else {
+                        await installAntigravityScope('global');
+                    }
                     break;
                 case 'project':
                     if (target === 'claude') {
                         await installScope('project', false);
                     }
-                    else {
+                    else if (target === 'codex') {
                         await installCodexScope('project');
                     }
+                    else {
+                        await installAntigravityScope('project');
+                    }
                     break;
                 case 'all':
                     if (target === 'claude') {
                         await installScope('global', useSymlink);
                         await installScope('project', false);
                     }
-                    else {
+                    else if (target === 'codex') {
                         await installCodexScope('global');
                         await installCodexScope('project');
                     }
+                    else {
+                        await installAntigravityScope('global');
+                        await installAntigravityScope('project');
+                    }
                     break;
             }
         }
@@ -477,7 +639,13 @@ export const installCommand = async (options) => {
         console.log(chalk.gray('    Restart Codex after global skill installation to pick up new skills'));
         console.log('');
     }
-    const otherTargets = targets.filter((t) => t !== 'claude' && t !== 'codex');
+    if (targets.includes('antigravity')) {
+        console.log(chalk.bold('  Antigravity:'));
+        console.log(chalk.gray('    Skills installed under ~/.gemini/skills or ./.gemini/skills'));
+        console.log(chalk.gray('    Architecture docs installed under ~/.gemini/architecture or ./.gemini/architecture'));
+        console.log('');
+    }
+    const otherTargets = targets.filter((t) => t !== 'claude' && t !== 'codex' && t !== 'antigravity');
     if (otherTargets.length > 0) {
         console.log(chalk.bold('  Other Editors:'));
         for (const target of otherTargets) {