Metadata-Version: 2.5
Name: igni-core
Version: 1.0.4
Summary: igni's backend and CLI: an AI coding assistant with multi-agent orchestration
Project-URL: Homepage, https://ignite-ember.sh
Project-URL: Repository, https://github.com/ignite-ember/igni-core
Project-URL: Issues, https://github.com/ignite-ember/igni-core/issues
Project-URL: Changelog, https://github.com/ignite-ember/igni-core/releases
Author: Ignite Ember
License-Expression: Apache-2.0
License-File: LICENSE
License-File: NOTICE
Keywords: agent,agno,ai,claude,coding-assistant,openai,tui
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Environment :: Plugins
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: MacOS
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Terminals
Requires-Python: <3.13,>=3.12
Requires-Dist: agno[ddg,mcp,openai,sql,sqlite]~=3.1.12
Requires-Dist: aiofiles~=25.1.0
Requires-Dist: aiosqlite~=0.22.1
Requires-Dist: alembic~=1.20.1
Requires-Dist: anthropic~=2.3.0
Requires-Dist: click~=8.5.0
Requires-Dist: cryptography~=50.0
Requires-Dist: dateparser~=1.4.0
Requires-Dist: dnspython~=2.9.0
Requires-Dist: google-genai~=2.34.0
Requires-Dist: greenlet~=3.5.1
Requires-Dist: httpx~=0.28.1
Requires-Dist: pydantic~=2.14.2
Requires-Dist: pyyaml~=6.0.3
Requires-Dist: rich~=15.0.0
Requires-Dist: ripgrep~=15.1.0
Requires-Dist: sqlalchemy[asyncio]~=2.1.6
Requires-Dist: textual~=8.2.7
Requires-Dist: tokenizers~=0.23.3
Requires-Dist: websockets~=16.0
Provides-Extra: anthropic
Requires-Dist: anthropic~=2.3.0; extra == 'anthropic'
Provides-Extra: decisions
Requires-Dist: laya~=0.4.20; extra == 'decisions'
Requires-Dist: starlette~=1.10.0; extra == 'decisions'
Requires-Dist: uvicorn~=0.54.0; extra == 'decisions'
Provides-Extra: dev
Requires-Dist: jsonschema~=4.26.0; extra == 'dev'
Requires-Dist: mypy~=2.4.1; extra == 'dev'
Requires-Dist: pytest-asyncio~=1.4.1; extra == 'dev'
Requires-Dist: pytest-cov~=7.1.0; extra == 'dev'
Requires-Dist: pytest~=9.2.0; extra == 'dev'
Requires-Dist: python-dotenv~=1.2.2; extra == 'dev'
Requires-Dist: ruff~=0.17.3; extra == 'dev'
Provides-Extra: gemini
Requires-Dist: google-genai~=2.34.0; extra == 'gemini'
Provides-Extra: mcp
Requires-Dist: mcp~=2.3; extra == 'mcp'
Provides-Extra: otel
Requires-Dist: openinference-instrumentation-agno~=1.1.2; extra == 'otel'
Requires-Dist: opentelemetry-exporter-otlp-proto-grpc~=1.45.2; extra == 'otel'
Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.45.2; extra == 'otel'
Requires-Dist: opentelemetry-instrumentation-httpx~=0.66b2; extra == 'otel'
Requires-Dist: opentelemetry-sdk~=1.45.2; extra == 'otel'
Provides-Extra: web
Requires-Dist: duckduckgo-search~=8.1; extra == 'web'
Description-Content-Type: text/markdown

# igni

[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/ignite-ember/igni-core/badge)](https://scorecard.dev/viewer/?uri=github.com/ignite-ember/igni-core)

**One spark ignites a team.** An AI coding assistant built with [Agno](https://github.com/agno-agi/agno) orchestration.

[ignite-ember.sh](https://ignite-ember.sh)

Inspired by [Claude Code](https://github.com/anthropics/claude-code), igni is a terminal-based coding agent that assembles specialized AI teams on the fly. Describe your task — the Orchestrator picks the right agents, the right team mode, and runs them.

## Why igni?

Claude Code uses a single agent loop — powerful but monolithic. igni takes a different approach: **dynamic multi-agent orchestration**. Instead of one agent doing everything, Agno's team system decomposes tasks, routes them to specialized agents, and synthesizes results — all automatically.

### The numbers

Head-to-head benchmark on a 12-case software-engineering suite, 5 runs per system, deterministic grading. See [docs/BENCHMARKS.md](docs/BENCHMARKS.md) for the full breakdown.

| | igni (MiniMax-M2.7) + CodeIndex | Claude Code (Opus-4.7) |
|---|---:|---:|
| Directly mergeable (✅) | **49 / 60 (82 %)** | 31 / 60 (52 %) |
| Needs clarification (⚠) | **4 / 60 (7 %)** | 22 / 60 (37 %) |
| Wrong target (❌) | 7 / 60 (12 %) | 7 / 60 (12 %) |
| Reproducibly correct cases (5/5 ✅) | **8 of 12** | 3 of 12 |
| Cost per run | **~$0.05** | $4.01 |
| Wall time mean | 2 331 s | **1 548 s** |

**igni wins by +18 ✅ trials at 1/80th the cost.** The gap is concentrated in the ⚠ band — igni commits to a concrete answer where Claude Code stays in design-conversation mode. Both systems hit the same hard-wrong rate (12 %), so the win comes from converting partial/clarifying responses into directly-mergeable ones.

The architectural choices that drive the gap: (1) **CodeIndex queried first, not files** — a pre-built semantic + metadata index lets the agent locate reuse targets and conventions by typed filter or HyDE-style code-shaped query, instead of grep-walking the repo. (2) **A mandatory "What already exists" preamble** — agent must name the reuse target, the closest near-miss it rejected, and the conventions to match before writing any code. (3) **A small, focused model with structured tools** — MiniMax-M2.7 + index access matches Opus-4.7 quality at 1/80th the price.

### Feature comparison

| Feature | Claude Code | igni |
|---|---|---|
| Architecture | Single agent loop | Multi-agent teams (Agno) |
| Task routing | Manual sub-agent spawning | Automatic via Coordinate/Route modes |
| Code intelligence | Grep + file reads | Shell-first reads; CodeIndex semantic search as a licensed extension |
| Project knowledge | None | The Artifacts extension (licensed; its own Neo4j store), served through your igni server |
| Planning | Plan mode (read-only) | Agno reasoning + Tasks mode |
| IDE integration | MCP server (stdio) | None — igni ships the desktop app, the web client and the CLI; MCP client (Agno MCPTools) |
| Extensibility | Plugins, hooks, MCP | Agents + hooks + toolkits + MCP |
| Agent evals | Not built-in | Built-in regression testing framework |
| Memory | File-based MEMORY.md | Agno Memory + DB-backed storage |
| Learning | None | Agno LearningMachine (user profiles, entity memory) |
| Guardrails | None | PII detection, prompt injection, moderation |
| HITL | Implicit | Explicit confirmation/input requirements |
| Default model | Anthropic Claude | Whatever your igni server routes to, or your own (model-agnostic) |

## Quick Start

```bash
brew install ignite-ember/tap/igni-core  # or: pip install igni-core (the old name ignite-ember works for both)
cd your-project
igni --read-only -m "In one sentence, what does this project do?"
```

`igni` is the command; `ignite-ember` is kept as an alias so existing
shell aliases and scripts keep working. Both are the same entry point,
and pip and the Homebrew formula both install both names.
On the command line it runs **one task and exits** (`-m`, or `-p` for a
pipe); there is no terminal chat UI any more — run it bare and it says so.

**What the published package holds today.** `igni-core` on PyPI is
**v1.0.4**, and it is this repository's build: the `igni_core` module,
the `igni` command and the decisions service. The old name installs the
same thing — `pip install ignite-ember` resolves to `igni-core==1.0.4`
through the alias (`packages/ignite-ember/` — metadata, and a dependency
on `igni-core` at the same version), and the Homebrew formula installs
`igni-core` as well. The command above works either way. To work on it
instead of installing it:

```bash
git clone https://github.com/ignite-ember/igni-core.git
cd igni-core
uv venv && uv pip install -e ".[dev]"
source .venv/bin/activate          # puts `igni` on your PATH
```
The interactive chat is the desktop app and the web client. A headless run cannot ask before it runs a command, so decide
up front what it may do. igni reads files with the shell, which asks by
default, so without `--read-only` the question above stops at its first
`cat` with *"Run paused for confirmation"* and exits 1 — see
[A headless run cannot ask you anything](QUICKSTART.md#a-headless-run-cannot-ask-you-anything).

To point it at your own igni server, set `api_url` in your user config,
`~/.igni/config.yaml` — not a project's `.igni/config.yaml` or
`config.local.yaml`, which may not name a server and are ignored for it,
with a warning — and run `igni login` (or `igni login --token-stdin` with a
token). That writes `~/.igni/credentials.json`, which `igni -m` and the desktop
app both use. `/login` is not a shell subcommand: `igni /login` answers
`Error: No such command`.

```yaml
# ~/.igni/config.yaml
api_url: https://igni-api.acme.example
# Only when the portal (the sign-in page) is not on the API's origin,
# e.g. the API on :7777 and the portal on :3000:
portal_url: https://igni.acme.example
```

`portal_url` is worked out from `api_url` when both run under one name and
differ by a host label (`api.acme.example` → `acme.example`); set it when
they differ any other way, such as by port, or sign-in opens a page the API
does not serve.

Or bring your own model (OpenAI, Anthropic, Groq, Ollama, etc.):

```bash
export OPENAI_API_KEY=sk-...
```

```yaml
# .igni/config.yaml
models:
  default: gpt-4o
  registry:
    gpt-4o:
      provider: openai_like
      model_id: gpt-4o
      url: https://api.openai.com/v1
      api_key: sk-...              # direct key in config
      # api_key_env: OPENAI_API_KEY  # or from env var
      # api_key_cmd: "op read ..."   # or from shell command
```

See [Quickstart](QUICKSTART.md) for the full setup guide.

### Quickstart (new setup)

1. **Install** — `pip install 'igni-core[decisions]==1.0.4'` (or
   `brew install ignite-ember/tap/igni-core`; the old name `ignite-ember` installs
   the same package from either).
2. **Configure a model** — set `OPENAI_API_KEY` (or any provider key) and add the
   model to `.igni/config.yaml`; or point `api_url` at your igni server and run
   `igni login`
3. **Run** — `igni -m "…"`, or the desktop app

See [Quickstart](QUICKSTART.md) for the full guide.

## Upgrading

The VS Code and JetBrains extensions are no longer shipped or supported;
release notes below that mention them are history.

### The split release (v1.0.3 → v1.0.4)

- **`igni-core` is on PyPI.** v1.0.4 is the first release published under igni's own name: `pip install 'igni-core[decisions]==1.0.4'` installs the `igni_core` module, the `igni` command and the decisions service. `ignite-ember` is now an alias — the same version, the same extras, nothing of its own — so `pip install ignite-ember` and the Homebrew formula install igni-core 1.0.4.
- **The cloud layer is its own package.** `igni-cloud` holds the PostgreSQL storage and the producer/guest binding, found through the `igni.layers` and `igni.storage` entry points, rather than inside the core.
- **The wire contract is typed.** The messages the backend and the app exchange have one definition, checked from both sides — the app's client is igni-core's contract, byte for byte.
- **One module per concern.** The backend is split into modules that each own one thing — settings, auth, the cloud, the tools, the transport — behind interfaces the tests can substitute. Nothing reaches into another's internals.
- **`igni login` is a command.** It opens the portal's sign-in page in a browser, takes the token back over a local callback, writes `~/.igni/credentials.json` and hydrates the group pack. `igni login --token-stdin` does it without a browser.
- **The Windows sandbox is behind one interface.** What it allows is one thing to state, and one thing to test.
- **An install made under the old name keeps working.** The desktop app still reads the cache directory and the install marker under their old names until the next write, so an app installed before the rename does not reinstall its runtime.

### Rebrand + signed desktop app (v0.7.0 → v0.7.1)

- **Rebrand to `igni`.** Shorter, single-word product name — the Tauri window, the macOS Dock, the VSCode + JetBrains marketplace listings, the welcome screen, the agent's self-identification all read `igni`. Internal identifiers (PyPI package `ignite-ember`, Python module `igni_core`, Tauri bundle id `sh.ignite-ember.desktop`, VSCode/JetBrains plugin slugs) are preserved so existing installs keep auto-updating without breakage.
- **`igni` CLI alias.** The terminal command is now `igni` (the old `ignite-ember` invocation still works for back-compat).
- **Apple Developer ID signing + notarization** on the macOS desktop app. First-launch no longer triggers the "unidentified developer" Gatekeeper warning; the notarization ticket is stapled into the `.app` so offline first-launch works too. The auto-updater pulls a fully signed + notarized bundle.
- **Mermaid diagrams in the chat.** Fenced ` ```mermaid ` blocks render as SVG (sequence / flowchart / state / ER / pie / gantt / mindmap / xy-chart / quadrant / timeline). Mermaid lazy-loads — first diagram in a session triggers the download.
- **Collapsible code blocks.** Anything taller than ~220px starts collapsed behind a chevron with a fade overlay; click anywhere on the clip (or the chevron) to expand. Copy chip stays always-visible top-right.
- **GitHub-Light syntax colors on light theme.** Stops the dark-dimmed `highlight.js` palette from painting neon-on-white when the user picks the light theme.
- **Per-turn stats restored on resumed conversations.** Re-opening a session now shows the same `✦ in · think · out · duration` pill the live path emits — chars/4 estimates pulled from each persisted run's content (Agno's raw `input_tokens` reads non-monotonic across iterations and was useless to restore literally).
- **Header drag-region fix.** The first user message's edit / delete chip is no longer captured by the Tauri shell's window-drag region — clicks reach the buttons.
- **Updater signature bug fixed (v0.7.1).** The macOS auto-updater's tarball-signature pair now matches at the asset level: stapled bytes are uploaded under the arch-suffixed name `latest.json` references, so signature verification succeeds. Anyone who installed v0.7.0 before this fix should update to v0.7.1 — the auto-updater itself will pull it through cleanly.

### GUI clients (v0.6.0 → v0.6.4)

- **Tauri desktop app.** Native window hosting the shared web UI; spawns the Python backend over a Unix socket, kills it on app exit (with `IGNI_PARENT_PID` watchdog for crash safety). macOS / Windows / Linux installers from CI; signed auto-updater backed by minisign.
- **VSCode extension.** WebView hosting the same shared UI; activates on workspace open with one command. Auto-installs `ignite-ember` via `uv` on first run — zero-touch.
- **JetBrains plugin.** JCEF panel hosting the same UI. Plugin SDK build wired into the release pipeline; published to the JetBrains Marketplace.
- **Shared web UI.** `clients/web` is the single React+TS surface; the three shells embed it. Single bundle, single React tree, single CSS — visual + behavioral parity across the three hosts.
- **Backend multi-session reliability.** SQLite hardening (WAL + checkpoint tuning), idle session eviction, slow-client back-pressure, sync-in-async call-site audit. Removes the long-running-session memory-leak class.
- **Release pipeline matured.** Marketplace publishing for VSCode + JetBrains; signed Tauri updater via minisign; per-tag draft → publish flow that avoids race-y duplicate releases under parallel matrix uploads. Pre-release tags (`-rc`) skip marketplace pushes + Homebrew updates so iteration doesn't pollute user-facing channels.
- **UI polish (v0.6.1).** Header / sidebar use a backdrop blur stack so messages frost as they scroll under; custom scroll-indicator thumbs (the native scrollbar would have rendered inside the blur layer); dark-theme icon variants.

**v0.5.0** is the "Beat Claude Code" release. Cumulative changes since v0.3.8:

### Benchmarks vs Claude Code (new in v0.5.0)

- **Head-to-head benchmark suite.** 12 cases × 5 runs vs Claude Code on the same target codebase. Programmatic deterministic grading. igni wins **49 / 60 ✅** vs **31 / 60 ✅** at one-eightieth of the per-run cost. Full breakdown in [docs/BENCHMARKS.md](docs/BENCHMARKS.md).
- **CodeIndex-first specialist agents.** New `*.codeindex.md` variants for `architect`, `debugger`, `explorer`, `reviewer`, `security`, `simplifier` — each with prompts tuned to query the index first instead of grepping. Auto-selected when a populated CodeIndex exists for the current commit.
- **Mandatory "What already exists" preamble.** The main-agent prompt now requires every code-write response to start with a four-bullet section naming (a) the reuse target, (b) the closest near-miss it considered and rejected, (c) the conventions to match, (d) the parallel infrastructure it will *not* introduce. Forces contrastive reasoning before code is written.
- **Encapsulation rule.** When a service class wraps a resource (db client, cache, queue, storage), new code must call methods on that class instead of inlining the raw client. Catches the "copy a private prefix into a new file and instantiate the client myself" anti-pattern.

### Plan-and-Align workflow (v0.4.2)

- **HITL approval for complex action work.** Main agent now plans first and waits for user approval before executing non-trivial tasks. Read-only review/audit work bypasses this and goes direct to the agent loop.
- **"Working with the User" framing.** Prompt restructured around "the human owns the bigger picture" — agent surfaces trade-offs, asks when uncertain, takes pushback seriously instead of defending its plan.
- **Strengthened safety rules.** Explicit handling for `.env` files, raw SQL, destructive shell commands, and blind-edit prevention.
- **Eval framework rebuilt.** Per-case Session isolation, per-case timeout overrides, `tool_arg_assertions` (e.g. asserts `spawn_team(mode="...")`), `prior_messages` for multi-turn cases, work-dir-aware file assertions. New eval suites for bulk_edits, file_safety, mcp, team_modes, team_tasks, knowledge_corner, knowledge_proactive, memory_knowledge, multiturn, error_recovery, long_running, schedule, web_discipline, background_notifications.

### Async shell + background notifications (v0.4.1)

- **Pure async shell tool.** `run_shell_command` / `read_process_output` / `watch_process` / `stop_process` / `list_processes` are now `async def` using `asyncio.create_subprocess_exec`. Previously blocked the event loop for up to the timeout (and a hard 3s on every `background=True` call), starving the HITL multiplexer drain and the FE message stream.
- **Background-process completion notifications.** When a backgrounded shell command finishes, the agent receives a queued `BACKGROUND PROCESS COMPLETED` notice with the output tail; the TUI also gets a `PushNotification`.
- **Idempotent `read_process_output`.** Multiple reads with different tails work; eviction moved to a 10-min TTL after the most recent read.
- **Schedule eval suite.** 12-case suite verifies the agent reaches for `Schedule` exactly when the user describes deferred/recurring work — and not otherwise. Achieves 12/12.

### Sub-agent HITL + run resumption (v0.4.0)

- **Sub-agent HITL bridge.** Specialist sub-agents (e.g. architect) can now request user confirmation through the same TUI flow as the main agent. Multiplexer was extracted from `run_message` and `resolve_hitl` so parent pauses no longer drop the specialist's pause requirements.
- **`acontinue_run` "No runs found" fix.** Session DB is now threaded into pool specialists and the `Team(...)` constructor so paused runs are persisted and can be resumed.
- **Concurrent-spawn race fix.** Per-spawn `copy.copy()` of pool specialists in `spawn_agent` / `spawn_team`. Without this, two concurrent spawns of the same specialist raced on shared `Agent` per-run state and Agno errored with "No runs found for run ID".
- **BE/TUI cleanup robustness.** Signal handlers, `atexit`, process-group kill, and an `IGNI_PARENT_PID` watchdog. Closes the runaway-BE failure mode where the TUI crash left a zombie backend.
- **`httpx` timeout actually applied.** Was previously shadowed by the SDK timeout when an `http_client` was provided.
- **Eval harness.** Auto-approve HITL drain, `--case-timeout` (default 60 s), `--case-retries` (default 2), `--spawn-timeout`, `retries=0` for determinism, WebSearch stub, ENV vs FAIL output classification, default concurrency 5.
- **New tests.** `test_subagent_hitl_e2e` (8 cases, bridge in isolation), `test_orchestrate_real_agno` (real Agno Agent + AsyncSqliteDb).
- **1363 tests pass.**

### Earlier v0.3.x fixes still relevant

**v0.3.8** includes the following changes:

- **Problem:** Escape key did not close the MCP panel (`/mcp`) or the task panel.
  - **Solution:** Added all dialog/panel widgets to the Escape handler, including MCPPanelWidget and TaskPanel.

**v0.3.7** includes the following changes:

- **Problem:** Edit/Write/Bash tools never asked for user confirmation, even when permissions were set to "ask".
  - **Solution:** `requires_confirmation` flag is now set on each function after registration in all custom toolkits.

**v0.3.6** includes the following changes:

- **Problem:** Debug logs grow unbounded and can fill up disk space.
  - **Solution:** Switched to RotatingFileHandler with 10MB limit and 2 backup files.

- **Problem:** Shell command output can be extremely large, causing issues when sending to the LLM.
  - **Solution:** Truncate tool results to 30,000 characters, keeping start and end of output.

- **Problem:** TUI escape key only closes the login dialog, leaving other panels open.
  - **Solution:** Now closes any open panel: login, help, model picker, or session picker.

- **Problem:** Learning features get stuck and never complete (caused by httpx connection pool issues in threads).
  - **Solution:** Run learning extraction as an async task on the main event loop instead of a separate thread.

To upgrade igni to the latest version:

```bash
brew upgrade ignite-ember/tap/igni-core
```

If `brew upgrade` doesn't work or you encounter issues, manually reinstall:

```bash
brew uninstall igni-core && brew untap ignite-ember/tap && brew tap ignite-ember/tap && brew install igni-core
```

## Clients

The Textual terminal UI was removed in v0.9.7, and the VS Code and JetBrains
extensions are no longer shipped. igni ships the desktop app (Tauri), the web
client and the CLI. The desktop app and the web client share one web UI,
both in [igni-app](https://github.com/ignite-ember/igni-app); the desktop app spawns the backend and talks to it over a WebSocket
(`python -m igni_core.backend --ws-port 0`). Features: streaming
responses, agent tree visualization, token tracking, session picker, keyboard
shortcuts, HITL confirmation dialogs. In a terminal, `igni -m` and `igni -p`
run one task.

## MCP

igni acts as an MCP *client*: configure external MCP servers via `/mcp` or the MCP panel and their tools become available to the agent.

> *Exposing igni itself as an MCP server (so any MCP-compatible IDE — Cursor, Windsurf, etc. — can connect to it) is on the roadmap; the `igni mcp serve` subcommand isn't shipped yet.*

## Key Features

### Project knowledge

There is no knowledge base in igni itself any more: the `knowledge:` settings
and `/knowledge` commands left with the Artifacts module, a separate licensed
service that keeps project documents and decisions in its own Neo4j store and
ships its extension through your igni server. A super admin approves the
service once; signed-in people get its tools.

### Learning & Reasoning

- **Learning** — Agno LearningMachine builds user profiles, entity memory, and session context across conversations
- **Reasoning tools** — `think` and `analyze` tools for step-by-step reasoning during complex tasks

### Guardrails

Built-in safety guardrails via Agno's pre-hook system:

```yaml
guardrails:
  pii_detection: true          # detect and flag PII in prompts
  prompt_injection: true       # detect injection attempts
  moderation: true             # OpenAI moderation API
```

### Human-in-the-Loop (HITL)

Agents can pause execution to request confirmation or user input before proceeding with sensitive operations. The desktop app and the web client show interactive approval dialogs; a headless `igni -m` cannot, so it follows the permission policy and stops at anything only a person could approve.

## Documentation

- **[Quickstart](QUICKSTART.md)** — Get up and running in under 5 minutes
- [Architecture](docs/ARCHITECTURE.md) — System design and agent topology
- [Agents](docs/AGENTS.md) — Specialized agents and their roles
- [Skills](docs/SKILLS.md) — Reusable prompted workflows (`/deploy`, `/resolve-issues`, etc.)
- [Onboarding](docs/ONBOARDING.md) — First-run setup, CodeIndex, and agent proposals
- [Tools](docs/TOOLS.md) — Available toolkits and capabilities
- [MCP](docs/MCP.md) — IDE integration via Model Context Protocol
- [Configuration](docs/CONFIGURATION.md) — Settings, permissions, and customization
- CodeIndex — semantic code intelligence engine; an extension, documented in the CodeIndex repository (`igni__code-index/docs/igni-integration.md`)
- [Benchmarks](docs/BENCHMARKS.md) — Head-to-head comparison vs Claude Code on a 12-case suite
- [Evals](docs/EVALS.md) — Agent evaluation framework and regression testing
- [Hooks](docs/HOOKS.md) — Pre/post tool execution hooks
- [Extensibility Floor](docs/EXTENSIBILITY.md) — The contract extensions build against, and what it guarantees them
- [Platform Plan](docs/PLATFORM_PLAN.md) — What has to be built for the single-user and shared backends, in order
- [UI package](https://github.com/ignite-ember/igni-sdk/tree/main/clients/ui) — The tokens, classes and components an extension builds against (in igni-sdk)
- [Design System](https://github.com/ignite-ember/igni-app/blob/main/docs/DESIGN_SYSTEM.md) — The scales, the primitives, and what still needs a human eye (in igni-app)
- [Build Plan](docs/BUILD_PLAN.md) — The same work as ordered items, with the files they touch and how each one is verified
- [Migration](docs/MIGRATION.md) — Coming from Claude Code or Codex
- [Security](docs/SECURITY.md) — Threat model, permissions, and enterprise hardening
- [Reporting a vulnerability](SECURITY.md) — where to send it, and what happens next
- [Verifying a release](docs/VERIFYING_RELEASES.md) — checksums, SBOMs, build provenance and signatures, online and air-gapped
- [Vulnerability management](docs/VULNERABILITY_MANAGEMENT.md) — what is scanned, what gates, and the remediation targets
- [Development](docs/DEVELOPMENT.md) — Contributing and extending igni

## License

Apache 2.0 — see [LICENSE](LICENSE) and [NOTICE](NOTICE).
