# Init

> Initialize cc-suite for the current project — sets up the AGENTS.md bridge, registers Codex, Claude, and Antigravity MCP surfaces, and generates a .cc-suite.md config. Skill counterpart to /cc-suite:init.

- Skill: `xiaolai/init` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add xiaolai/init`
- Raw SKILL.md: https://api.skillmd.com/api/skills/xiaolai/init/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML, Coding & Dev Tools
- Author: xiaolai (https://skillmd.com/u/xiaolai)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/xiaolai/init

---


# Init

Bootstrap cc-suite in the current project.

## When to Use

- Setting up a project for the first time
- Re-initializing after cloning a repo that already has `AGENTS.md`
- Walks through the same setup flow as `/cc-suite:init` — useful when the agent should drive the steps in conversation rather than via a slash command

## Workflow

### Step 0: Resolve the plugin root

`CLAUDE_PLUGIN_ROOT` is set by Claude Code only — in a Codex or Antigravity session it is unset. Resolve the root from the bridged skills symlink (it points at `<plugin-root>/skills/cc-suite`):

```bash
PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(dirname "$(dirname "$(readlink -f .claude/skills/cc-suite 2>/dev/null)")")}"
[ -d "${PLUGIN_ROOT}/scripts" ] || echo "! cannot resolve the cc-suite plugin root — run /cc-suite:bridge-skills from Claude Code first, or export CLAUDE_PLUGIN_ROOT"
```

Every command below uses `${PLUGIN_ROOT}`. Stop if it could not be resolved.

### Step 1: Check for existing config

```bash
[ -f .cc-suite.md ] && echo "exists" || echo "missing"
```

If it exists, read it and ask the user:
- **Show** — display the file and stop
- **Regenerate** — replace with a fresh config (proceed through questions)
- **Cancel** — keep as-is and stop

### Step 2: Detect project stack

Run these checks to build the stack description:

```bash
[ -f package.json ]                                   && echo "node"
[ -f requirements.txt ] || [ -f pyproject.toml ]      && echo "python"
[ -f go.mod ]                                         && echo "go"
[ -f Cargo.toml ]                                     && echo "rust"
[ -f Gemfile ]                                        && echo "ruby"
[ -f pom.xml ] || [ -f build.gradle ]                 && echo "java"
ls *.csproj *.sln 2>/dev/null                         && echo "dotnet"
[ -f jest.config.js ] || [ -f vitest.config.ts ]      && echo "jest/vitest"
[ -f pytest.ini ] || [ -f conftest.py ]               && echo "pytest"
[ -d src ]  && echo "src/"
[ -d lib ]  && echo "lib/"
[ -d app ]  && echo "app/"
```

Detect the test command from what the project declares — a framework marker
alone does not establish the command:
- `package.json`: read `scripts.test`. Missing or the npm placeholder
  (`Error: no test specified`) → **unknown**. Otherwise pick the runner from
  the lockfile: `pnpm-lock.yaml` → `pnpm test`, `yarn.lock` → `yarn test`,
  `bun.lock*` → `bun run test`, else `npm test`.
- `pytest.ini` / `conftest.py` → `pytest`
- `go.mod` with `*_test.go` files → `go test ./...`
- `Cargo.toml` → `cargo test`
- `Gemfile` + `spec/` → `bundle exec rspec`
- Nothing reliable → write `unknown` rather than guessing.

### Step 3: Discover the current Codex default

Run the shared Codex preflight before asking for configuration:

```bash
bash "${PLUGIN_ROOT}/scripts/codex-preflight.sh"
```

Use `default_model` and the per-model `reasoning_efforts` (from the
`models_detail` entry matching `default_model`; top-level `reasoning_efforts`
for older preflight output) to phrase the questions in Step 4. The preflight
dynamically prefers the latest available general-purpose model and deprioritizes
review-only entries, so they are never the default while a general model exists.

Do not write the resolved `default_model` slug into the config unless the user
explicitly pins it in Step 4 — the config records a policy (`latest`, or a
deliberate pin), not a snapshot. If the preflight cannot discover models, skip
the model question and write `latest`.

### Step 4: Ask customization questions (conversational)

Ask the user four questions in sequence (three when preflight failed — skip the
model policy question and write `latest`):

1. **Audit focus** — balanced / security-first / performance-first / quality-first (default: balanced)
2. **Audit depth** — mini (5 dimensions, faster) / full (9 dimensions) (default: mini)
3. **Model policy** — track latest (default; currently resolves to `{default_model}`, never goes stale) / pin `{default_model}` (fixed until the user edits `.cc-suite.md`)
4. **Reasoning effort** — offer the levels from the selected per-model `reasoning_efforts` list (default: `high` when available, otherwise the highest offered; fall back to high / medium / low when preflight failed or the list is empty)

### Step 5: Generate .cc-suite.md

Write `.cc-suite.md` to the project root:

````markdown
# CC-Suite Configuration

Project-specific settings for cc-suite commands.
Generated by `/cc-suite:init`. Edit freely — all fields are optional.

## Project

- **Stack**: {detected stack}
- **Test command**: {detected test command or "unknown"}
- **Source directories**: {detected dirs}

## Defaults

These override the built-in defaults for all commands in this project.
Remove a line to fall back to the built-in default.
`latest` is a policy, not a model name: Codex-delegating commands resolve it to
the newest general-purpose Codex model via preflight. Replace it with a concrete
slug (any entry from the preflight model list) only to pin — pins stop tracking
the catalog.

- **Default model**: {"latest", or the pinned slug if the user chose to pin}
- **Default effort**: {chosen effort}
- **Default audit type**: {chosen audit type}
- **Default sandbox**: workspace-write

## Audit Focus

{chosen focus}

Additional instructions appended to every audit's developer-instructions:

```text
{focus-specific instructions}
```

## Skip Patterns

Files and directories to always skip during audits (glob patterns):

```text
node_modules/
dist/
build/
coverage/
*.min.js
*.bundle.js
*.lock
vendor/
.git/
```

## Project-Specific Instructions

Custom instructions appended to Codex's developer-instructions for every command.

```text
{stack-derived instructions from Step 2 detection, e.g. "This is a {detected stack} project. Follow existing patterns in {detected dirs}." Leave empty when nothing was detected.}
```
````

Focus-specific instructions:
- **balanced**: "Give equal attention to all audit dimensions."
- **security-first**: "Prioritize security findings. Flag any auth bypass, injection, data exposure, or cryptographic weakness as Critical regardless of other severity heuristics."
- **performance-first**: "Prioritize performance findings. Flag N+1 queries, O(n²) algorithms, memory leaks, and blocking I/O as High regardless of other severity heuristics."
- **quality-first**: "Prioritize code quality findings. Flag untested critical paths, high cyclomatic complexity, and DRY violations as High regardless of other severity heuristics."

### Step 6: Bridge init

```bash
bash "${PLUGIN_ROOT}/scripts/init.sh"
```

Creates `AGENTS.md`, `CLAUDE.md` (`@AGENTS.md`), Codex scaffolding, the
`.agents/skills` bridge, and the `.gitignore` block. (The generated
`.agents/mcp_config.json` projection is written later, by `bridge_mcp.sh` in
Step 8.) Antigravity CLI (`agy`) reads `AGENTS.md` natively and uses `.agents/`
workspace assets. It does not create new Gemini-era project scaffolding. Skips
each artifact if already correct.

### Step 7: Expose skills

```bash
bash "${PLUGIN_ROOT}/scripts/bridge_skills.sh"
```

### Step 8: Register codex-cli MCP server

```bash
bash "${PLUGIN_ROOT}/scripts/mcp_codex.sh"
bash "${PLUGIN_ROOT}/scripts/bridge_mcp.sh"
```

The bridge writes the Codex projection and the generated agy workspace MCP
projection. It also registers the pinned `claude-code` server for agy → Claude.

### Step 9: Register claude-code MCP server

```bash
bash "${PLUGIN_ROOT}/scripts/mcp_claude.sh"
```

### Step 10: Final status

```bash
bash "${PLUGIN_ROOT}/scripts/status.sh"
```

Report:

```
cc-suite initialized

Bridge artifacts: {status summary}
Claude → Codex:  .mcp.json has codex-cli registered ✓
Codex → Claude:  .codex/config.toml has claude-code registered ✓
agy → Claude:    .agents/mcp_config.json has claude-code when the projection is available ✓
Project config:  .cc-suite.md written ({focus}, {depth}, effort={effort})

Next steps:
  Edit AGENTS.md to add project-specific conventions
  Run /cc-suite:audit-fix to test the full cycle
  Run /cc-suite:diagnose to verify health at any time
  Commit AGENTS.md, .cc-suite.md, .mcp.json to share with your team
```

## Example Invocations

<example>
Context: A brand-new project needs cc-suite set up from inside the conversation.
user: "Set cc-suite up for this project and walk me through the choices."
assistant: "I'll run the init skill — it detects the stack, asks the setup questions, then bootstraps AGENTS.md and the MCP registrations."
</example>

<example>
Context: The repo already carries an AGENTS.md written for another tool.
user: "There's already an AGENTS.md here from Codex — can cc-suite still work?"
assistant: "I'll use init, which detects the existing AGENTS.md and adds the cc-suite bridge artifacts around it rather than overwriting it."
</example>