@drafthq/draft 2.7.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,38 @@
+{
+  "name": "draft-plugins",
+  "owner": {
+    "name": "mayurpise",
+    "url": "https://github.com/mayurpise"
+  },
+  "metadata": {
+    "description": "Context-Driven Development plugins for Claude Code"
+  },
+  "plugins": [
+    {
+      "name": "draft",
+      "source": "./",
+      "description": "Context-Driven Development: draft specs and plans before implementation. Structured workflows for features and fixes.",
+      "version": "2.7.0",
+      "author": {
+        "name": "mayurpise"
+      },
+      "homepage": "https://github.com/drafthq/draft",
+      "license": "MIT",
+      "keywords": [
+        "context-driven-development",
+        "ai-assisted",
+        "planning",
+        "specifications",
+        "architecture",
+        "code-review",
+        "monorepo",
+        "tdd",
+        "validation",
+        "enterprise",
+        "incremental-refresh",
+        "signal-detection",
+        "state-management"
+      ]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,26 @@
+{
+  "name": "draft",
+  "description": "Context-Driven Development: draft specs and plans before implementation. Structured workflows for features and fixes.",
+  "version": "2.7.0",
+  "author": {
+    "name": "mayurpise"
+  },
+  "homepage": "https://github.com/drafthq/draft",
+  "license": "MIT",
+  "keywords": [
+    "context-driven-development",
+    "ai-assisted",
+    "planning",
+    "specifications",
+    "architecture",
+    "code-review",
+    "monorepo",
+    "tdd",
+    "validation",
+    "enterprise",
+    "incremental-refresh",
+    "signal-detection",
+    "state-management"
+  ],
+  "skills": "./skills/"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mayur Pise
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,272 @@
+<h1 align="center">Draft</h1>
+
+<p align="center">
+  <strong>Stop shipping AI-generated bugs.</strong><br>
+  One command runs a three-stage review on your branch — validation, spec compliance, code quality — and writes the missing tests. Free. Open-source. MIT.
+</p>
+
+<p align="center">
+  <a href="https://github.com/drafthq/draft/releases"><img src="https://img.shields.io/github/v/release/drafthq/draft?include_prereleases&style=for-the-badge" alt="GitHub release"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" alt="MIT License"></a>
+  <a href="https://github.com/drafthq/draft/stargazers"><img src="https://img.shields.io/github/stars/drafthq/draft?style=for-the-badge" alt="Stars"></a>
+  <a href="https://github.com/DeusData/codebase-memory-mcp" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/badge/graph_engine-codebase--memory--mcp-8A2BE2?style=for-the-badge" alt="Graph engine: codebase-memory-mcp"></a>
+</p>
+
+<p align="center">
+  Powered by <a href="https://github.com/DeusData/codebase-memory-mcp" target="_blank" rel="noopener noreferrer">codebase-memory-mcp</a> by <a href="https://github.com/DeusData" target="_blank" rel="noopener noreferrer">DeusData</a> — a 159-language, 100% local knowledge-graph engine.
+</p>
+
+<p align="center">
+  <a href="https://getdraft.dev">Website</a> ·
+  <a href="https://getdraft.dev#commands">Docs</a> ·
+  <a href="core/methodology.md">Methodology</a> ·
+  <a href="https://www.youtube.com/watch?v=gBSwFEFVd7Y">Watch (8 min)</a> ·
+  <a href="https://www.youtube.com/playlist?list=PLoN73NRJ_HQPdnR5Su4WkWK-O_7IOrOg_">All Videos</a>
+</p>
+
+---
+
+## The 60-second pitch
+
+Your AI assistant just wrote 200 lines. Some of them are bugs. Some don't match your patterns. Some skip tests.
+
+```bash
+/draft:review
+```
+
+Three stages, one command:
+
+1. **Validation** — runs your tests, lints, type-checks, and surfaces real failures
+2. **Spec compliance** — checks the diff against the agreed spec, not vibes
+3. **Code quality** — flags hotspots, blast radius, and missing test coverage using a tree-sitter knowledge graph of your repo
+
+Free. No API keys. No paid tier. No vendor lock-in. Catches the 3 bugs you missed before they hit your reviewer.
+
+> *Demo coming soon — for now, [watch the 8-minute walkthrough](https://www.youtube.com/watch?v=gBSwFEFVd7Y).*
+
+---
+
+## Install (30 seconds)
+
+One command installs Draft into your agent. No clone, no config.
+
+```bash
+npx @drafthq/draft install <host>      # claude-code | cursor | codex | opencode
+```
+
+…or install the CLI once and reuse it:
+
+```bash
+npm install -g @drafthq/draft
+draft install <host>
+draft list                             # show every host + where it installs
+```
+
+| Host | `draft install …` | Lands in |
+|------|-------------------|----------|
+| **Claude Code** | `claude-code` | `./.claude-plugin/` + `skills/` `core/` (project) |
+| **Cursor** | `cursor` | `~/.cursor/plugins/local/draft/` (global) |
+| **Codex** | `codex` | `./AGENTS.md` (project) |
+| **opencode** | `opencode` | `./AGENTS.md` + `~/.agents/skills/draft/` |
+
+Flags: `--global` / `--project` to pick scope, `--dry-run` to preview writes, `--force` to overwrite, `--no-graph` to skip the graph-engine fetch.
+
+Then, in Claude Code:
+
+```bash
+/draft:init       # 5-phase codebase analysis (one-time)
+/draft:review     # ← run this on every branch before you push
+```
+
+Run `/draft` for the full command map.
+
+<details>
+<summary><strong>Other ways to install →</strong></summary>
+
+### Claude Code — native marketplace
+```bash
+/plugin marketplace add drafthq/draft
+/plugin install draft
+```
+
+### Cursor — from GitHub
+Cursor natively supports the `.claude-plugin/` structure. Add via *Settings > Rules, Skills, Subagents > Rules > New > Add from Github*:
+```
+https://github.com/drafthq/draft.git
+```
+
+### GitHub Copilot
+Copilot reads a committed instructions file — copy it directly (not a `draft install` host):
+```bash
+mkdir -p .github && curl -o .github/copilot-instructions.md \
+  https://raw.githubusercontent.com/drafthq/draft/main/integrations/copilot/.github/copilot-instructions.md
+```
+
+### Gemini
+```bash
+curl -o .gemini.md https://raw.githubusercontent.com/drafthq/draft/main/integrations/gemini/.gemini.md
+```
+
+</details>
+
+---
+
+## Beyond `/draft:review` — 27 more commands
+
+`/draft:review` is the wedge. Once Draft has indexed your repo, you also get spec-driven planning, TDD-enforced implementation, exhaustive bug hunting, deep architectural audits, and 23 more commands covering the full development lifecycle.
+
+---
+
+## What You Get
+
+| Command | What It Does |
+|---------|--------------|
+| **`/draft`** | Overview, intent mapping, and command reference |
+| **`/draft:init`** | Analyze codebase, create context files + state tracking |
+| **`/draft:index`** | Aggregate monorepo service contexts |
+| **`/draft:new-track`** | Collaborative spec + plan with AI |
+| **`/draft:decompose`** | Module decomposition with dependency mapping |
+| **`/draft:implement`** | TDD workflow with checkpoints |
+| **`/draft:coverage`** | Code coverage report (target 95%+) |
+| **`/draft:review`** | 3-stage review (validation + spec compliance + code quality) |
+| **`/draft:deep-review`** | Enterprise-grade module lifecycle and ACID audit |
+| **`/draft:bughunt`** | Exhaustive 14-dimension defect discovery with taint tracking |
+| **`/draft:learn`** | Discover coding patterns, update guardrails |
+| **`/draft:adr`** | Architecture Decision Records |
+| **`/draft:status`** | Show progress overview |
+| **`/draft:revert`** | Git-aware rollback |
+| **`/draft:change`** | Handle mid-track requirement changes |
+| **`/draft:debug`** | Structured debugging: reproduce, isolate, diagnose, fix |
+| **`/draft:quick-review`** | Lightweight 4-dimension code review |
+| **`/draft:deploy-checklist`** | Pre-deployment verification with rollback triggers |
+| **`/draft:testing-strategy`** | Test plan design with coverage targets |
+| **`/draft:tech-debt`** | Technical debt analysis across 6 dimensions |
+| **`/draft:standup`** | Git activity standup summary (read-only) |
+| **`/draft:incident-response`** | Incident lifecycle: triage, communicate, mitigate, postmortem |
+| **`/draft:documentation`** | Technical docs: readme, runbook, api, onboarding |
+| **`/draft:jira`** | Unified Jira workflows (preview / create / review) |
+| **`/draft:tour`** | Interactive architecture mentorship and codebase walk-through |
+| **`/draft:impact`** | ROI analytics tracking friction and timeline metrics |
+| **`/draft:assist-review`** | Summarize intent and highlight structural PR risks for reviewers |
+
+[See full command reference →](core/methodology.md#command-workflows)
+
+> **Recommended next step after install:** run `/draft:init` to index your repo, then `/draft:review` on any branch with AI-generated changes. Once you've seen what it catches, explore the rest.
+
+---
+
+## Built-in Code Intelligence
+
+Draft is powered by a **local knowledge graph engine** ([codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)) that gives every command precise structural context — module boundaries, call graphs, dependencies, hotspots. It's 100% local (no API key, no SaaS), installed on first use.
+
+```bash
+/draft:graph                                  # build / refresh the snapshot
+scripts/tools/graph-impact.sh --file src/auth/login.go
+# → blast radius: which files, which symbols, which tests/docs/configs
+```
+
+| Capability | What it provides |
+|---|---|
+| **Multi-language extraction** | Tree-sitter + LSP-grade resolution across 159 languages, 100% local |
+| **Call graph** | Callers/callees with confidence signals so review/bughunt can weight findings |
+| **Impact analysis** | Blast-radius with file-class dimension (code/test/doc/config) — answers *"what breaks if I change this?"* |
+| **Cycle detection** | Flags circular call dependencies before they bite |
+| **Hotspot ranking** | Fan-in score so high-risk symbols get extra scrutiny |
+| **Incremental indexing** | git-aware, content-based; only changed code re-indexes |
+| **Track impact memory** | `metadata.json.impact` snapshots each completed track's blast radius — `/draft:new-track` flags overlap with recent work |
+
+The graph powers `/draft:graph` and `/draft:impact`, enriches `/draft:bughunt` and `/draft:review`, and is consumed by skills via `core/shared/graph-query.md`. The engine is installed via [`scripts/fetch-memory-engine.sh`](scripts/fetch-memory-engine.sh); the deterministic shell helpers live under [`scripts/tools/`](scripts/tools/).
+
+### Deterministic helper tools
+
+Skills also call into **14 shell helpers** under `scripts/tools/` for mechanical work — git metadata, file classification, test-framework detection, hotspot ranking, freshness checks, ADR indexing. All emit JSON, follow a uniform exit-code contract, and degrade gracefully when their input source is unavailable.
+
+---
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        /draft:init                          │
+│    5-phase codebase analysis + signal detection + state     │
+│  architecture.md + .ai-context.md + .state/ (freshness,    │
+│                   signals, run memory)                      │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+                             ▼
+┌─────────────────────────────────────────────────────────────┐
+│                      /draft:new-track                       │
+│            AI-guided spec.md + phased plan.md               │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+                             ▼
+┌─────────────────────────────────────────────────────────────┐
+│                     /draft:implement                        │
+│              RED → GREEN → REFACTOR (repeat)                │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+                             ▼
+┌─────────────────────────────────────────────────────────────┐
+│                      /draft:review                          │
+│        Three-stage review (validation + spec + quality)     │
+└─────────────────────────────────────────────────────────────┘
+
+         /draft:init refresh  ←── incremental: only re-analyze
+                                   files with changed hashes
+```
+
+[Full workflow →](core/methodology.md#core-workflow)
+
+---
+
+## Why Draft?
+
+AI tools are fast but unstructured. Draft applies Context-Driven Development to impose clear boundaries: explicit context, phased execution, and built-in verification, ensuring outputs remain aligned, predictable, and production-ready.
+
+```
+product.md       →  "Build a task manager"
+tech-stack.md    →  "React, TypeScript, Tailwind"
+architecture.md  →  Comprehensive: 28 sections + 5 appendices, Mermaid diagrams (source of truth). Mature brownfield projects with strong existing agent docs (CLAUDE.md, INVARIANTS.md, etc.) receive early Context Quality Audit, graph fidelity dashboard, and explicit Relationship + Gaps sections (no blind duplication).
+.ai-context.md   →  200-400 lines: condensed from architecture.md (token-optimized AI context)
+.state/          →  freshness hashes, signal classification, run memory (incremental refresh)
+spec.md          →  "Add drag-and-drop reordering"
+plan.md          →  "Phase 1: sortable, Phase 2: persist"
+```
+
+Each layer narrows the solution space. By the time AI writes code, decisions are made.
+
+**Incremental refresh**: After initial setup, `/draft:init refresh` uses stored file hashes and signal classification to only re-analyze what changed — no full re-scan needed.
+
+[Read methodology →](core/methodology.md#philosophy)
+
+---
+
+## Contributing
+
+### Source of Truth
+1. `core/methodology.md` — Master methodology
+2. `skills/<name>/SKILL.md` — Command implementations
+3. `integrations/` — Auto-generated (don't edit)
+
+### Update Workflow
+```bash
+# 1. Edit core/methodology.md or skills/*/SKILL.md
+# 2. Rebuild integrations
+./scripts/build-integrations.sh
+```
+
+[Full architecture →](CLAUDE.md)
+
+---
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=drafthq/draft&type=Date)](https://star-history.com/#drafthq/draft&Date)
+
+---
+
+<p align="center">MIT License &middot; Graph engine: <a href="https://github.com/DeusData/codebase-memory-mcp" target="_blank" rel="noopener noreferrer">codebase-memory-mcp</a> by <a href="https://github.com/DeusData" target="_blank" rel="noopener noreferrer">DeusData</a></p>
+
+<p align="center">
+  <strong>Credits:</strong> Inspired by <a href="https://github.com/gemini-cli-extensions/conductor">gemini-cli-extensions/conductor</a>
+</p>

package/bin/README.md

@@ -0,0 +1,49 @@
+# Knowledge-Graph Engine
+
+Draft's knowledge graph is powered by **[codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)** — a single static binary that indexes a repository into a SQLite knowledge graph (functions, classes, modules, files, routes, and their CALLS/DEFINES/IMPORTS edges) and answers structural queries.
+
+## Not vendored — fetched on install
+
+Unlike the previous Aether `graph` binary, the engine is **not committed to this repo** (it is ~250 MB per platform). Instead it is downloaded on install:
+
+```bash
+scripts/fetch-memory-engine.sh          # fetch pinned version for this host
+CMM_VERSION=latest scripts/fetch-memory-engine.sh   # or a specific tag / latest
+```
+
+This installs the binary to the **Draft-managed location**:
+
+```
+~/.cache/draft/bin/codebase-memory-mcp
+```
+
+The fetch script picks the right release archive for the host OS/arch, verifies its SHA-256 against the published `checksums.txt`, extracts it, and installs it there. `draft install claude-code` / `draft install cursor` run this automatically (best-effort, network-gated); skip it with `--no-graph`.
+
+## Resolution order
+
+`scripts/tools/_lib.sh:find_memory_bin()` resolves the engine in this order:
+
+1. `DRAFT_MEMORY_BIN` — explicit override (pinned installs, testing)
+2. `codebase-memory-mcp` on `$PATH` — global/dev installs
+3. `~/.cache/draft/bin/codebase-memory-mcp` — the managed install location
+4. `bin/<os>-<arch>/codebase-memory-mcp` under the plugin/repo root — optional vendored fallback (offline/air-gapped distributions only)
+
+Architecture strings are normalized to `linux-amd64`, `linux-arm64`, `darwin-amd64`, `darwin-arm64`.
+
+There is **no legacy fallback** to the retired Aether `graph` / `graph-clang` binaries.
+
+## Opting out
+
+Set `DRAFT_MEMORY_DISABLE=1` to force the engine off. All graph-backed skills and tools degrade gracefully (they report `source: unavailable` / emit empty stubs) when the engine cannot be resolved.
+
+## How tools use it
+
+Shell helpers under `scripts/tools/` drive the engine via its CLI
+(`codebase-memory-mcp cli <tool> '<json>'`) and shape results into Draft's
+contracts — see `hotspot-rank.sh`, `cycle-detect.sh`, `mermaid-from-graph.sh`,
+and `verify-graph-binary.sh`. The shared wrappers (`memory_cli`,
+`memory_ensure_index`, `memory_project_for_repo`) live in `_lib.sh`.
+
+## Offline / air-gapped distributions
+
+To ship the engine in-tree, place the binary at `bin/<os>-<arch>/codebase-memory-mcp` (resolution step 4). This is optional and not the default; the managed fetch is preferred.

package/cli/bin/draft.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+'use strict';
+
+// Entry point for the `draft` CLI. Keeps argv parsing and dispatch in src/cli.js
+// so this stays a thin, dependency-free launcher.
+const { run } = require('../src/cli');
+
+run(process.argv.slice(2))
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    console.error(err && err.message ? err.message : String(err));
+    process.exit(1);
+  });

package/cli/src/cli.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const os = require('os');
+const { hosts, getHost } = require('./hosts');
+const { install } = require('./installer');
+const log = require('./lib/log');
+const pkg = require('../../package.json');
+
+function parseFlags(args) {
+  const flags = { scope: null, dryRun: false, graph: true, force: false };
+  const positionals = [];
+  for (const a of args) {
+    switch (a) {
+      case '--global': flags.scope = 'global'; break;
+      case '--project':
+      case '--local': flags.scope = 'project'; break;
+      case '--dry-run': flags.dryRun = true; break;
+      case '--no-graph': flags.graph = false; break;
+      case '--force': flags.force = true; break;
+      default:
+        if (a.startsWith('-')) {
+          throw new Error(`Unknown flag: ${a}`);
+        }
+        positionals.push(a);
+    }
+  }
+  return { flags, positionals };
+}
+
+function printHosts() {
+  log.info('\nSupported hosts:');
+  for (const h of hosts) {
+    log.info(`  ${h.id.padEnd(12)} ${h.label}  (${h.defaultScope} install)`);
+  }
+  log.info('\nUsage: draft install <host> [--global|--project] [--dry-run] [--no-graph] [--force]');
+}
+
+function printHelp() {
+  log.info(`draft — install the Draft Context-Driven Development methodology into your AI coding agent
+
+Usage:
+  draft install <host> [flags]   Install Draft for a host
+  draft list                     List supported hosts
+  draft --version                Print version
+  draft --help                   Show this help
+
+Hosts: ${hosts.map((h) => h.id).join(', ')}
+
+Flags:
+  --global        Install to the user-level location (default for cursor)
+  --project       Install into the current project (default for claude-code, codex, opencode)
+  --dry-run       Print planned writes without touching disk
+  --no-graph      Skip the knowledge-graph engine fetch
+  --force         Overwrite an existing target
+
+GitHub Copilot / Gemini are not hosts — copy the committed instructions file directly:
+  .github/copilot-instructions.md   or   .gemini.md   from github.com/drafthq/draft`);
+}
+
+function cmdInstall(args) {
+  const { flags, positionals } = parseFlags(args);
+  const hostId = positionals[0];
+  if (!hostId) {
+    log.error('Missing host. Usage: draft install <host>');
+    printHosts();
+    return 1;
+  }
+  const host = getHost(hostId);
+  if (!host) {
+    log.error(`Unknown host: ${hostId}`);
+    printHosts();
+    return 1;
+  }
+  const ctx = {
+    cwd: process.cwd(),
+    home: os.homedir(),
+    env: process.env,
+    scope: flags.scope || host.defaultScope,
+    dryRun: flags.dryRun,
+    force: flags.force,
+    graph: flags.graph,
+  };
+  return install(host, ctx);
+}
+
+async function run(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case undefined:
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp();
+      return 0;
+    case 'version':
+    case '--version':
+    case '-v':
+      log.info(pkg.version);
+      return 0;
+    case 'list':
+    case 'hosts':
+      printHosts();
+      return 0;
+    case 'install':
+      return cmdInstall(rest);
+    default:
+      log.error(`Unknown command: ${cmd}`);
+      printHelp();
+      return 1;
+  }
+}
+
+module.exports = { run, parseFlags };

package/cli/src/hosts/claude-code.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const path = require('path');
+const { asset } = require('../lib/paths');
+
+// Draft's native plugin shape: the .claude-plugin manifest + skills/core/bin and
+// the deterministic shell helpers the skills invoke. Copied into the project root
+// so Claude Code (and Cursor, which shares the format) discovers it locally.
+const ITEMS = [
+  { p: '.claude-plugin', kind: 'copyTree' },
+  { p: 'skills', kind: 'copyTree' },
+  { p: 'core', kind: 'copyTree' },
+  { p: 'bin', kind: 'copyTree' },
+  { p: 'scripts/tools', kind: 'copyTree' },
+  { p: 'scripts/fetch-memory-engine.sh', kind: 'copyFile' },
+  { p: 'scripts/lib.sh', kind: 'copyFile' },
+];
+
+module.exports = {
+  id: 'claude-code',
+  label: 'Claude Code',
+  aliases: ['claude', 'claudecode'],
+  defaultScope: 'project',
+
+  plan(ctx) {
+    const root = ctx.cwd;
+    const actions = ITEMS.map((it) => ({
+      kind: it.kind,
+      src: asset(it.p),
+      dest: path.join(root, it.p),
+      label: it.p,
+      // Guard on the manifest dir: its presence marks a prior Draft install.
+      guard: it.p === '.claude-plugin',
+    }));
+
+    return {
+      targetSummary: `${root} (project)`,
+      actions,
+      graph: true,
+      done: 'Draft plugin copied into the project. Run /draft in Claude Code to see the commands.',
+      notes: [
+        'Alternative (no npm): /plugin marketplace add drafthq/draft  then  /plugin install draft',
+      ],
+    };
+  },
+};

package/cli/src/hosts/codex.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const path = require('path');
+const { asset } = require('../lib/paths');
+
+// Codex reads an AGENTS.md from the repo root. Draft ships a generated AGENTS.md
+// (the full inlined methodology) — drop it in place. Guarded so we never clobber
+// an existing AGENTS.md without --force.
+module.exports = {
+  id: 'codex',
+  label: 'OpenAI Codex',
+  aliases: ['codex-cli'],
+  defaultScope: 'project',
+
+  plan(ctx) {
+    const dest = path.join(ctx.cwd, 'AGENTS.md');
+    return {
+      targetSummary: `${dest} (project)`,
+      actions: [
+        {
+          kind: 'copyFile',
+          src: asset('integrations', 'agents', 'AGENTS.md'),
+          dest,
+          label: 'AGENTS.md',
+          guard: true,
+        },
+      ],
+      graph: false,
+      done: 'Wrote AGENTS.md — Codex reads it automatically from the repo root.',
+      notes: ['Commit AGENTS.md so your whole team shares the Draft methodology.'],
+    };
+  },
+};

package/cli/src/hosts/cursor.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const { asset } = require('../lib/paths');
+
+// Cursor natively understands the .claude-plugin structure. Install the same
+// native plugin tree, by default to the user-level plugin directory so it is
+// available across all projects.
+const ITEMS = [
+  { p: '.claude-plugin', kind: 'copyTree' },
+  { p: 'skills', kind: 'copyTree' },
+  { p: 'core', kind: 'copyTree' },
+  { p: 'bin', kind: 'copyTree' },
+  { p: 'scripts/tools', kind: 'copyTree' },
+  { p: 'scripts/fetch-memory-engine.sh', kind: 'copyFile' },
+  { p: 'scripts/lib.sh', kind: 'copyFile' },
+];
+
+function cursorHome(ctx) {
+  return ctx.env.CURSOR_HOME || path.join(ctx.home, '.cursor');
+}
+
+module.exports = {
+  id: 'cursor',
+  label: 'Cursor',
+  aliases: [],
+  defaultScope: 'global',
+
+  plan(ctx) {
+    const base = ctx.scope === 'project'
+      ? path.join(ctx.cwd, '.cursor', 'plugins', 'local', 'draft')
+      : path.join(cursorHome(ctx), 'plugins', 'local', 'draft');
+
+    const actions = ITEMS.map((it) => ({
+      kind: it.kind,
+      src: asset(it.p),
+      dest: path.join(base, it.p),
+      label: it.p,
+    }));
+    // Guard the whole install dir on the manifest's presence.
+    actions[0].guard = true;
+
+    return {
+      targetSummary: `${base} (${ctx.scope})`,
+      actions,
+      graph: true,
+      done: `Draft installed to ${base}. Restart Cursor to detect the plugin.`,
+    };
+  },
+};