idea-to-deploy — плагин Claude Code: функции и установка

# idea-to-deploy

> Harness Engineering methodology for reliable agentic software delivery, with a
> model-neutral contract, state, and verification core.

One canonical core is currently packaged and validated for **Claude Code** and
**OpenAI Codex** through host adapters. Other agent hosts are an architectural
extension point, not a supported claim. [Choose a host](#quick-start) ·
[Architecture](#architecture-and-portability) ·
[End-to-End Example](#end-to-end-example) · [Skill Contracts](#skill-contracts).

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Skills: 41](https://img.shields.io/badge/Skills-41-green.svg)](#skills)
[![Agents: 10](https://img.shields.io/badge/Agents-10-orange.svg)](#subagents)
[![Version: 1.109.2](https://img.shields.io/badge/Version-1.109.2-purple.svg)](CHANGELOG.md)
[![meta-review](https://github.com/hihol-labs/idea-to-deploy/actions/workflows/meta-review.yml/badge.svg)](https://github.com/hihol-labs/idea-to-deploy/actions/workflows/meta-review.yml)
[![Status: Stable](https://img.shields.io/badge/Status-Stable-brightgreen.svg)](CHANGELOG.md)
[![Type: Harness Engineering](https://img.shields.io/badge/Type-Harness%20Engineering-blueviolet.svg)](docs/HARNESS_ENGINEERING_MAP.md)

**[Русская версия (README.ru.md)](README.ru.md)** · **[Changelog](CHANGELOG.md)** · **[Contributing](CONTRIBUTING.md)** · **[CI](docs/CI.md)**

> **Idea to Deploy is the product name; Harness Engineering is the methodology
> category.** The repository contains one shared methodology core plus separate
> [Claude Code](.claude-plugin/plugin.json) and
> [Codex](.codex-plugin/plugin.json) packages. It does not run as a standalone CLI.

## Demo

<p align="center">
  <img src="docs/demo.svg" alt="idea-to-deploy kickstart demo" width="788">
</p>

> See the [End-to-End Example](#end-to-end-example) below for a detailed walkthrough.
> The recording predates the Codex adapter and shows the Claude Code transport;
> the lifecycle and verification contracts are shared.

---

## The Problem

AI coding agents are powerful, but without a harness they work like builders
without blueprints:
- Writes code randomly, skips tests, doesn't document
- Each time produces different structure and quality
- Can break what already works
- No methodology — just chaotic generation

## The Solution

**idea-to-deploy** is a methodology, not just a set of tools. Its
41 skills + 10 specialized agents, 31 hooks, project contracts, and persistent
state give a supported coding host an evidence-gated delivery pipeline:

```
Idea → Questions → Plan → Architecture → Code → Tests → Review → Deploy
```

Every step is verified. Every feature is tested. Every decision is documented. Every session is preserved.

## Architecture and portability

```text
                     Idea to Deploy
        canonical Harness Engineering methodology core
    skills · .itd contracts · .itd-memory · hooks · tests
                           |
                host adapter contract
                  /                     \
       Claude Code adapter          Codex adapter
       CLAUDE.md / hooks       AGENTS.md / dispatcher
```

Host adapters translate packaging, guidance files, tool names, hook events, and
subagent transport. They may not fork completion criteria, risk policy,
persistent project state, or skill semantics. See the
[host adapter contract](docs/HOST_ADAPTER_CONTRACT.md).

Acceptance is proof-carrying by default: low-risk work uses harness-executed
machine evidence, medium adds a targeted fresh-session checker, and
high/unknown adds a full checker from a fresh session and different model or
provider. `/goal` and review caches accept only an exact-candidate adjudication
receipt; see [Verification Loop v1](docs/VERIFICATION_LOOP.md).

Opt-in [operating loops](docs/OPERATING_LOOPS.md) add binary readiness
diagnostics, routing to existing skills, report-only host-native schedules,
temporary capability-bound trust, observed append-only telemetry, deterministic
failure handling, and provenance-backed outcome stories. They do not add a
daemon or unattended permanent authority. The closed recipe registry contains
exactly six report-first loops: state freshness, test regression, dependency
health, security posture, review drift, and documentation drift.

| Host | Status | Guidance entry | Evidence boundary |
|---|---|---|---|
| Claude Code | Supported | `CLAUDE.md` | Native plugin, skills, agents, and hooks |
| OpenAI Codex | Supported | `AGENTS.md` | Native package plus tested hook/tool normalization |
| Other agent hosts | Not validated | Adapter-defined | Requires an adapter, declared degradations, and parity evidence |

**What “model-neutral” means here:** the load-bearing contracts, state, gates,
and evidence rules do not depend on the identity of a particular model.
It does **not** mean that every model or agent host works out of the box, that
all hosts expose identical capabilities, or that current model recommendations
are provider-equivalent.

## Quick Start

### Claude Code

**Requirements:** Claude Code CLI ≥ 2.0 (or its VS Code / JetBrains extension)
with plugin support, an eligible Claude subscription, and `git` on `PATH`.

Install the Claude Code adapter:

```bash
/plugin install hihol-labs/idea-to-deploy
```

The skills and agents are then registered under:

```
~/.claude/plugins/idea-to-deploy/
  ├── skills/          # 41 skill directories
  ├── agents/          # 10 subagent definitions
  └── hooks/           # enforcement hooks - /adopt and /project offer to install them
```

Sanity check inside Claude Code:

```
/project
```

If the router prompt appears and offers routes A / B / C, the plugin is live.

Update:

```bash
/plugin update hihol-labs/idea-to-deploy
```

Uninstall:

```bash
/plugin uninstall hihol-labs/idea-to-deploy
```

### OpenAI Codex

Enable this repository through the normal Codex plugin UI and review its
bundled command hooks with `/hooks` before trusting them. The Codex adapter
uses `.codex-plugin/plugin.json`, `AGENTS.md`, and automatic
`hooks/hooks.json` discovery.

For a repository-local checkout instead of an installed package, follow the
[Codex adapter setup](docs/CODEX_ADAPTER.md#enable-and-trust). It documents the
local `.codex/hooks.json` fallback and the known transport differences.

On both hosts, `git` is required by lifecycle, review, and continuity
workflows. See the [CHANGELOG](CHANGELOG.md) for release notes.

### Updating - one installation for every project

The methodology lives in the installation, not in a project: rules, hooks,
skills and the `.itd` tools (`itd_hygiene.py`, `itd_progress.py`,
`check_contract_drift.py`, `itd_init_validate.py`) run from the installed copy
through `skills/_shared/itd_tool.sh`. An adopted project holds only its own
contracts (`.itd/*.json`, `*.md`), its state (`.itd-memory/`) and a short pointer
block in `CLAUDE.md` / `AGENTS.md`. Updating the installation therefore updates
every project on the machine:

- Claude Code: update the plugin, then bring the checkout to the same release
  and synchronize from it - a stale checkout would copy old files over the new
  installation:

  ```bash
  git -C ~/idea-to-deploy-src pull --ff-only
  ```

  ```bash
  bash ~/idea-to-deploy-src/scripts/sync-to-active.sh
  ```

  The sync installs hooks, skills, templates and the managed global `CLAUDE.md`
  block.
- Codex: refresh the plugin through the Codex plugin UI.

One fallback remains for compatibility: when no installed copy of a tool is
found at all, `itd_tool.sh` runs a legacy project copy `.itd/<tool>.py` left by
an older `/adopt` and warns about it on stderr. Keep the installation current to
avoid running such a stale copy.

Projects adopted by older versions may still carry a copied rules block or
copied `.itd/*.py` tools. List them read-only (nothing is changed; with Codex run the
same file from the plugin root):

```bash
python3 ~/.claude/skills/_shared/itd_projects_doctor.py ~/projects
```

### Usage

In either supported host, describe what you want:

```
I want to build a food delivery service
```

The active host adapter will:
1. Ask which route you prefer (full cycle / planning only / have docs)
2. Ask clarifying questions about your project
3. Generate architecture and documentation
4. **Show you the plan and wait for your approval**
5. Build the project step by step
6. Test and review after each step
7. Deploy

When you're done for the day, just say:

```
save session
```

Your session context — decisions, progress, blockers, next steps — will be saved and automatically restored in your next session.

## How It Works

```
You: "I want to build a delivery app"
         |
         v
    /project (smart router)
         |
    Asks: A, B, or C?
         |
    +----+--------+--------+
    v              v              v
  A) Full        B) Plan       C) Guide
  Cycle          Only          Only
    |              |              |
    v              v              v
 /kickstart    /blueprint     /guide
    |
    +-- Asks clarifying questions
    +-- Generates 7 documents
    +-- Runs /review (auto-validation)
    +-- PAUSE: shows plan, waits for approval
    +-- Scaffolds project
    +-- Implements step by step:
    |     +-- /test after each feature
    |     +-- Code vs Architecture check
    |     +-- Fix issues before next step
    +-- Deploys
```


## End-to-End Example

A minimal walkthrough of Route A (full cycle):

```
You:   I want to build a Telegram bot that tracks my gym workouts
Agent:  [/project] A, B, or C?
You:   A
Agent:  [/kickstart] asks 6 clarifying questions
        (users? auth? DB? hosting? budget? deadline?)
You:   personal use, no auth, SQLite, local, $0, this weekend
Agent:  generates STRATEGIC_PLAN, PROJECT_ARCHITECTURE,
        IMPLEMENTATION_PLAN, PRD, README, CLAUDE_CODE_GUIDE, CLAUDE.md
        runs /review → PASSED_WITH_WARNINGS (2 nits)
        shows plan, asks: "Approve and start coding?"
You:   yes
Agent:  Step 1/9 — scaffold project, commit
        Step 2/9 — DB models + /test
        ...
        Step 9/9 — deploy script + README update
        Done. 42 tests passing. Here is your bot.
```

The legacy-compatible `CLAUDE.md` and `CLAUDE_CODE_GUIDE.md` names in this
example are current generator outputs, not a claim that the methodology core is
Claude-only. Host-neutral output naming remains follow-up work.

**Reference fixtures:** reproducible golden-path scenarios used by the test runner live in [`tests/fixtures/`](tests/fixtures/). Run them with [`tests/run-fixtures.sh`](tests/run-fixtures.sh) to see how each skill behaves on a known input.

**Current progress / verification entry points:** the living progress log is [CHANGELOG.md](CHANGELOG.md) (per-release, includes rationale); `ROADMAP_v*.md` files are historical. To verify the whole system locally run `bash tests/run-all.sh` (mirrors both CI workflows; `--quick` for the static core); the release procedure and its known pitfalls live in [docs/RELEASE_RUNBOOK.md](docs/RELEASE_RUNBOOK.md).

## Skills

### Entry Points (6 skills)

| Skill | Description |
|-------|-------------|
| `/project` | Smart router for **creating** something — asks one question and routes to /kickstart, /blueprint, or /guide |
| `/task` | Smart router for **working on existing code** — routes to the right daily-work skill (/bugfix, /refactor, /doc, /test, /perf, /review, ...) based on the task type |
| `/adopt` | Onboard a legacy project through the active host adapter — `CLAUDE.md` + `.claude/settings.json` on Claude Code, or `AGENTS.md` + Codex hooks on Codex — then bootstrap canonical `.itd/` contracts and `.itd-memory/` state. No reverse-engineering of plan docs. |
| `/discover` | **New in v1.17.0.** Product discovery phase — market analysis (TAM/SAM/SOM), competitor research, user personas, feature prioritization (MoSCoW + RICE). Outputs `DISCOVERY.md` ready for `/blueprint`. |
| `/strategy` | **New in v1.19.0.** Strategic replanning for existing projects — 5-dimension gap analysis, option generation with devil's advocate, ADR for pivot decisions, LAUNCH_PLAN.md updates. |
| `/advisor` | **New in v1.19.0.** Advisory/consulting mode — analysis-only (no code changes), multi-perspective evaluation via business-analyst + devils-advocate subagents. |

### Project Creation (3 skills)

| Skill | Route | What it does |
|-------|-------|-------------|
| `/kickstart` | A) Full cycle | Idea to deployed product: docs, code, tests, deploy |
| `/blueprint` | B) Planning only | 6 documentation files, no code |
| `/guide` | C) Have docs already | You already have architecture and plan docs (from route B, another developer, or another tool) — generates step-by-step prompts to build it |

### Quality Assurance (6 skills)

| Skill | Description |
|-------|-------------|
| `/review` | Validates documentation/code with the deterministic rubric and uses the same mandatory route-bound producer whenever the Verification Loop risk route requires an independent checker (medium/high/unknown; low remains the explicit machine-only route). No caller can downgrade the selected route (BLOCKED / PASSED_WITH_WARNINGS / PASSED). |
| `/security-audit` | Read-only OWASP-style security audit (auth, secrets, injection, CORS/CSP, deps) with same status enum as `/review` |
| `/security-guidance-setup` | **New in v1.29.0.** Security companion — sets up & integrates the official [security-guidance plugin](https://github.com/anthropics/claude-code/tree/main/plugins/security-guidance) by Anthropic (free, ships default-on). A shift-left, always-on reviewer of Claude-generated code: regex pattern warnings on every Edit/Write, an LLM diff review on Stop (findings fed back before you see the turn), and an agentic commit/push reviewer tracing cross-file vulns (IDOR, auth bypass, SSRF). Detects install, prints the verified CLI command, maps it onto the lifecycle. **Complements** `/security-audit` (on-demand audit), does **not** replace it; does not vendor upstream code; gates unaffected. |
| `/cross-review` | Mandatory independent pre-PR review over the exact staged candidate. Uses one fresh opposite-GPT `Sol -> Terra` / `Terra -> Sol` route through `itd_free_reviewer_producer.py`, with no automatic provider fallback or quorum. There is no caller bypass, and acceptance remains owned by evidence-first Verification Loop adjudication. Anthropic, Copilot, Antigravity and paid adapters are optional operations infrastructure. |
| `/grill-me` | **New in v1.21.0.** Interactive read-only stress-test for plans, designs, architecture, and risky decisions — asks one question at a time (with a recommended answer) to surface assumptions, risks, and dependencies. Runs before `/review`, does not replace it. |
| `/browser-check` | **New in v1.21.0.** Local browser smoke-test for frontend/full-stack/visual flows via a bundled Playwright harness (Browser Use / in-app browser fallback) — checks first render + critical path (navigation, forms, states). Broken render/flow → BLOCKED before deploy. |

### Daily Work (6 skills)

| Skill | Description |
|-------|-------------|
| `/test` | Generate unit, integration, and edge case tests |
| `/bugfix` | Systematically find and fix bugs (was `/debug` before v1.4.0 — renamed to avoid collision with Claude Code's built-in `/debug` slash command) |
| `/perf` | Performance analysis and optimization |
| `/refactor` | Improve code structure without changing behavior |
| `/explain` | Explain how code works with ASCII diagrams |
| `/doc` | Generate documentation matching project style |

### Quality Assurance — Supply Chain (1 skill, new in v1.4.0)

| Skill | Description |
|-------|-------------|
| `/deps-audit` | Read-only dependency audit — parses lockfiles, queries OSV.dev + GitHub Advisory for known CVEs, SPDX license compatibility, abandoned-package detection (> 2y without release). Same status enum as `/review`. |

### Operations (5 skills)

| Skill | Description |
|-------|-------------|
| `/migrate` | Apply database migrations safely — backup, apply, verify, document rollback. Refuses production without explicit confirmation. |
| `/migrate-prod` | **New in v1.19.0.** Migrate running production services between hosts — inventory, setup target, data migration, dual-run, DNS cut-over, rollback plan, decommission. |
| `/deploy` | **New in v1.19.0.** Deploy to production — sync files (tar-over-ssh), regenerate gateway config, build Docker image, restart containers, apply pending migrations, verify healthcheck. Refuses without explicit user confirmation; always calls `/session-save` after. |
| `/harden` | **New in v1.4.0.** Production-readiness hardening rubric — health checks, graceful shutdown, structured logging, rate limiting, Prometheus/Grafana, backup strategy, k6 load tests, SRE runbook. Generates missing artifacts on user approval. |
| `/infra` | **New in v1.4.0.** Infrastructure-as-code generator — Terraform modules (DigitalOcean, AWS, Hetzner), Kubernetes manifests + Helm chart, secrets wiring (Vault, AWS Secrets Manager, Doppler, Sealed Secrets). Remote tfstate with locking enforced for prod. |

### Workflow (6 skills)

| Skill | Description |
|-------|-------------|
| `/session-save` | Save session context to canonical project-local memory — what was done, key decisions, blockers, next steps. Ensures continuity across supported host sessions. |
| `/autopilot` | Auto-pipeline that runs discover → blueprint → kickstart → review → test with minimal human intervention (GSD-inspired). Takes a project idea and produces a full project with all docs, code, tests, and review. |
| `/handoff` | **New in v1.21.0.** Write a compact `HANDOFF.md` context packet to transfer work to the next session/agent when there is no return path — compaction, delegation, AFK run, or recovery. Distinct from `/session-save` (milestone save). |
| `/goal` | **New in v1.44.0.** Long-goal mode — decompose a multi-session goal into ordered verifiable units in `.itd-memory/GOAL.json` (user approval required), drive them one at a time through the standard `/task` pipeline (WIP=1, evidence-gated `verified`), and resume across sessions from the first non-verified unit. Its bounded envelope now enforces observed token/time/attempt stops, routes checker cost by sealed risk tier, emits ≤4 KB checkpoints, and can grade clean A/B evidence with a deterministic anti-Goodhart 5/5 evaluator. Brownfield-first; never bypasses `/review`, `/test`, or the DoD. |
| `/retro` | **New in v1.46.0.** Self-proposing improvement cycle for the methodology itself, split FACTS / PROPOSALS / MERGE: `itd_retro_scan.py` deterministically aggregates telemetry (VCR, regressions, active goals, SKILL_BYPASS ledger, cost), the model turns facts into ranked proposals where every one cites evidence (anti-Goodhart: external signals only), and the human merges via the ordinary release pipeline. Never edits the methodology itself; not a gate. |
| `/graph` | **New (unreleased).** Graph Lite — turn ONE task into an explicit agent graph (jobs, arrows, shared state, a checker separate from the writer, a human terminal), get the owner to approve the exact graph digest, run it through the host workflow runtime (or node by node when the host has none) and keep every node output as a file under `.itd-memory/graph-runs/<run-id>/`. Default-off (`disable-model-invocation`), read-only nodes, a measured exception to ADR-012 (ADR-013); the shipped template `module-neighbour-check` hunts four defect classes (owner, money, dedup, time) across a whole money/access module. |

### Research (2 skills)

| Skill | Description |
|-------|-------------|
| `/market-scan` | **New in v1.21.0.** Fresh public market & community signal scan (~30-day window via the `last30days` engine) for discovery, validation, ICP, competitor, and launch decisions. Normalizes findings into `MARKET_BRIEF.md` (dated append). Distinct from `/discover` (full discovery phase). |
| `/mcp-docs` | **New in v1.21.0.** Read-only lookup of fresh library/framework documentation via MCP providers (Context7) — resolves a library ID, asks a narrow question, records source + decision. Use before adding dependencies or integrating against SDKs. |

### Integration (4 skills)

| Skill | Description |
|-------|-------------|
| `/github-workflow` | **New in v1.21.0.** GitHub Issues / PR / CI / release workflow — inspects PR & check status (connector or `gh`), debugs failing Actions before code changes, prepares branches/changelogs/release notes, keeps `.rubric-status` aligned. Explicit-invocation; no push/merge/close/release without explicit intent. |
| `/tool-sync` | **New in v1.21.0.** Mirror idea-to-deploy artifacts to external tools — GitHub, Linear, Notion, Google Drive, Obsidian. Connector-native reads before writes (reconcile, never clobber), export-only fallback to `.itd-integrations/`. Explicit-invocation. |
| `/obsidian-export` | **New in v1.21.0.** Export planning docs, handoff, memory, state, decisions, and gates into an Obsidian-compatible local knowledge graph under `.itd-integrations/obsidian/`. Derived & regenerable — canonical docs stay the source of truth. |
| `/seo-setup` | **New in v1.28.0.** SEO companion — sets up & integrates the upstream [Claude SEO plugin](https://github.com/AgriciDaniel/claude-seo) (MIT), which ships 25 sub-skills + 18 sub-agents for technical SEO, content quality (E-E-A-T), Schema.org, sitemaps, Core Web Vitals, local SEO, backlinks, AI/GEO, hreflang, and the Google SEO APIs. Detects install, runs/prints the verified CLI commands, and maps it onto the lifecycle (discover→keyword/competitor, blueprint→schema/hreflang, kickstart→on-page, harden→technical/CWV/GEO, deploy→drift baseline + Google APIs). Named `-setup` to avoid colliding with upstream's own `seo` skill. Does **not** vendor upstream code; gates are unaffected. |

### Efficiency (2 skills)

| Skill | Description |
|-------|-------------|
| `/caveman` | **New in v1.26.0.** Token-efficiency communication mode — terse caveman-style replies (`lite`/`full`/`ultra`/`wenyan-*`) that cut output tokens ~75% while keeping full technical accuracy. Port of the public [Caveman plugin](https://github.com/JuliusBrussee/caveman) (MIT). idea-to-deploy gates still win over brevity: never compresses gate status, blockers, verification evidence, security warnings, or destructive confirmations. Style control only — does not replace `/review`, `/test`, or any work route. |
| `/context-mode-setup` | **New in v1.27.0.** Context-window optimization companion — sets up & integrates the upstream [Context Mode plugin](https://github.com/mksglu/context-mode) (ELv2), which sandboxes large tool output into a local FTS5 store so the agent searches it (`ctx-search`) instead of dumping it into context (vendor claim ~98% per-call reduction). Detects install, runs/prints the verified CLI commands, and maps its `ctx-*` skills onto the lifecycle (long `/kickstart` builds, long `/task`/`/bugfix` sessions). Named `-setup` to avoid colliding with upstream's own `context-mode` skill. Does **not** vendor upstream ELv2 code; gates are unaffected. |

## Subagents

Heavy skills run in isolated contexts with specialized agents for better quality:

| Agent | Used by | Specialization |
|-------|---------|---------------|
| `architect` | `/blueprint` | Database schemas, API design, tech stack selection |
| `code-reviewer` | `/review` | Cross-document validation, consistency checks, scoring |
| `test-generator` | `/test` | Comprehensive test coverage, edge cases, mocking |
| `perf-analyzer` | `/perf` | Bottleneck detection, N+1 queries, algorithm optimization |
| `doc-writer` | `/doc` | README, API docs, inline comments, style matching |
| `business-analyst` | `/discover` | Market analysis, competitor research, user personas, feature prioritization |
| `devils-advocate` | `/advisor`, `/strategy`, `/blueprint` | Adversarial reviewer — challenges architectural and strategic decisions, proposes counter-arguments before implementation |
| `researcher` | `/market-scan`, `/mcp-docs`, `/discover` | Bounded market/technical/docs research that changes product, architecture, dependency, or integration decisions |
| `security-reviewer` | `/security-audit`, `/harden` | Read-only security audit — exploitability/impact ranking, remediation plan, never prints secrets |
| `ux-reviewer` | `/browser-check`, `/review` | Browser-based UX/visual/accessibility review of user-facing changes — prefers Playwright evidence over static guesses |

## Skill Contracts

> **Note for users:** in normal use, you do **not** invoke skills manually. Describe your task in natural language (*"I want to build X"*, *"fix this bug"*, *"add tests for this function"*) and the active host adapter routes it through skill discovery and trigger-phrase matching. Skills also invoke each other in chains — see the [Call Graph](#call-graph) section below. The contracts table exists for debugging, contributions, and explicit control; it is **not** a "list of commands you must memorize".

Each skill has a documented contract — what it reads, what it writes, what side effects it has, and whether it's safe to run twice.

| Skill | Inputs | Outputs (files written) | Side effects | Idempotent |
|---|---|---|---|:---:|
| `/project` | User idea (text) | None directly — routes to another skill | None | ✅ |
| `/task` | Task description (text) for an existing project | None directly — routes to /bugfix, /refactor, /doc, /test, /perf, /review, /security-audit, /deps-audit, /migrate, /harden, /infra, or /explain | None (router only) | ✅ |
| `/discover` | Product idea or problem statement | `DISCOVERY.md` (market analysis, personas, prioritization) | None (analysis only, no code) | ✅ |
| `/kickstart` | User idea + clarifications | 7 docs + scaffolded project + commits | Git commits, file scaffolding, possible deploy | ⚠️ Resumes from CLAUDE.md status |
| `/blueprint` | User idea + clarifications | 6 docs + CLAUDE.md + .gitignore | None (planning only, no code) | ⚠️ Asks before overwrite |
| `/guide` | Existing PROJECT_ARCHITECTURE.md + IMPLEMENTATION_PLAN.md | CLAUDE_CODE_GUIDE.md | None | ✅ |
| `/review` | All project docs + code (read-only) | Validation report (stdout) + optional fix patches | Optional doc fixes if user agrees | ✅ |
| `/test` | File/function/module path | New test files matching project conventions | New test files only | ✅ |
| `/bugfix` | Error message / stack trace / symptom | Code patch fixing root cause + optional regression test | Source file edits | ⚠️ Should not be re-run after fix |
| `/refactor` | File/function/area | Refactored code preserving behavior | Source file edits | ✅ Behavior preserved |
| `/perf` | File/function/area + perf complaint | Bottleneck report + optimization patches | Source file edits, possibly DB index DDL | ⚠️ Measure between runs |
| `/explain` | File/function/concept | Markdown explanation + ASCII diagrams (stdout) | None | ✅ |
| `/doc` | File/module or "readme"/"api" | New/updated docs (README, API docs, inline comments) | Doc file edits | ✅ |
| `/security-audit` | File/dir/`all` | Audit report (stdout) — Critical/Important/Recommended/Informational tiers | None (read-only by design) | ✅ |
| `/deps-audit` | Manifest file/dir/`all` | Audit report (stdout) — CVE/license/abandoned tiers, same enum as /review | None (read-only, no package mutations) | ✅ |
| `/migrate` | Migration file/`next`/raw SQL | Migration applied + backup file + report with rollback path | DB schema mutation, backup file written to /tmp | ⚠️ Refuses on prod without confirmation |
| `/harden` | Service/dir/`all` | Hardening report + optional generated artifacts (health route, lifespan, logger, k6 script, runbook) | Code additions only with user approval; no deletions | ⚠️ Artifact generation is stateful |
| `/infra` | Stack preset + target (do/aws/hetzner/k8s) | Terraform modules OR Helm chart + README with deploy commands | New files under `infra/`; no cloud API calls (read-only from cloud side) | ✅ Generation is deterministic per input |
| `/session-save` | Session end signal or explicit invocation | Project-local `.itd-memory/session_*.md` checkpoint + `MEMORY.md` update | Writes canonical continuity under `.itd-memory/`; a host-private mirror is optional compatibility only | ✅ Creates a new checkpoint each time |
| `/autopilot` | Project idea (text) | Full project: docs + code + tests + review report | Git commits, file scaffolding, possible deploy (runs discover → blueprint → kickstart → review → test chain) | ⚠️ Stateful pipeline with multiple phases |
| `/strategy` | Existing project + context of what changed | Updated `LAUNCH_PLAN.md` + ADR + `BACKLOG.md` | File writes (plan docs only, no code) | ✅ Creates/overwrites plan docs |
| `/migrate-prod` | Source host + target host + service list | `MIGRATION_PLAN.md` + executed migration steps | SSH, Docker, DNS changes, DB dumps — **production impact** | ⚠️ Production operations, requires confirmation |
| `/advisor` | Question, comparison, or strategic decision | Analysis report (stdout) — pros/cons/risks | None (read-only by design, no Write/Edit) | ✅ |
| `/deploy` | Service name (`web`, `all`, or specific) + git HEAD | Deployed containers + healthcheck result (stdout) | SSH to target host, file sync, Docker build, container restart, optional DB migration — **production impact** | ⚠️ Production operations, requires confirmation |
| `/adopt` | Existing repo path (defaults to `cwd`) + optional `skip-chain` | Host guidance/config (`CLAUDE.md` + `.claude/settings.json`, or `AGENTS.md` + Codex hooks), canonical `.itd/`, `.itd-memory/` | Project-local writes only; voice-chain invokes `/strategy` or `/blueprint` | ✅ Marker-based idempotency |
| `/grill-me` | Plan / design / architecture / decision (text or repo) | None — questions + analysis (stdout); optional artifact only if the user asks | None (read-only by default; no Write/Edit) | ✅ |
| `/handoff` | Project state + handoff reason (...