omniconductor 0.3.0

package/adapters/cursor/README.md

@@ -0,0 +1,87 @@
+# Adapter — Cursor (T1, partial support)
+
+Cursor is a strong CONDUCTOR target because:
+
+- It supports per-pattern rule scoping via `.cursor/rules/*.mdc` `globs:` front-matter — close to Claude's lazy rule loading.
+- It supports an always-loaded baseline via `.cursorrules`.
+- Its `.cursor/commands/*.md` provide a partial slash-command analog.
+- Its rule UI surfaces which rules loaded for the current file, useful for debugging.
+
+It is **partial T1** because:
+
+- ❌ No sub-agent dispatch — single chat session per task.
+- ❌ No hooks — cannot ABSOLUTE-enforce spec-as-you-go or two-stage code review.
+- ❌ No per-call model routing — model is per-session.
+- ❌ No built-in memory directory — DIY at `.memory/`.
+
+**Tier**: T1 — Full support for what Cursor itself supports; partial vs Claude's reference implementation due to missing sub-agents/hooks.
+
+## Installation path
+
+```bash
+# Install (the cursor adapter is implemented):
+bash /path/to/conductor/adapters/cursor/transform.sh /path/to/target [--dry-run]
+
+# (planned / roadmap — not yet available):
+# npx omniconductor init --target=cursor [target-dir]
+```
+
+## What gets installed
+
+```
+<target>/
+├── .cursorrules                                # Always-loaded baseline
+├── .cursor/
+│   └── rules/
+│       ├── operations.mdc                      # globs: **
+│       ├── coding-conventions.mdc              # globs: **/*.{ts,tsx,...}
+│       ├── token-economy.mdc                   # globs: **
+│       ├── spec-as-you-go.mdc                  # globs: docs/specs/**, **/*.md
+│       └── model-routing.mdc                   # globs: ** (informational)
+└── docs/
+    ├── CURRENT_WORK.md                         # (universal templates, identical to other adapters)
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## Native features supported
+
+- ✅ Always-loaded baseline (`.cursorrules`).
+- ✅ Per-pattern rule scoping (`globs:` on `.mdc`).
+- ✅ All universal rule TEXT.
+- ✅ All doc templates.
+- ⚠️ Project commands (partial slash-command analog).
+
+## Features NOT supported (Cursor limitations)
+
+| Feature | Workaround |
+|---|---|
+| Sub-agent dispatch | Human plays orchestrator role manually. The orchestrator manual section in `.cursorrules` serves as the prompt template when starting a complex task. |
+| Hooks (Stop / PreToolUse) | Not available. Pair with a project-level pre-commit git hook for enforcement. |
+| Per-call model routing | Cursor uses one model per session. Switch sessions to switch model. Pick the right model in Cursor UI before starting a complex task. |
+| Built-in memory directory | DIY at `<target>/.memory/`. Add to `.gitignore`. |
+| Specialized review agents (Stage A / Stage B) | Run review prompts manually in Cursor chat. |
+
+## After install — first steps
+
+1. Open the target project in Cursor.
+2. Open the rule indicator (Cursor UI shows which rules loaded for the current file). Verify the universal rules appear.
+3. Customize `.cursorrules` — replace `{{PROJECT_NAME}}` placeholder.
+4. Rename `docs/specs/_example.md` → `docs/specs/<your-area>.md` and start a real spec.
+5. Add `.memory/` to `.gitignore`. Create your first memory entry.
+6. Add your first entry to `docs/CURRENT_WORK.md`.
+
+## Quirks / known issues (P2 will fill)
+
+To be filled in `notes.md` after P2 real-install verification on Cursor.
+
+## Status (P0 foundation)
+
+- ✅ `README.md`
+- ✅ `SUPPORTED-FEATURES.md`
+- ✅ `transform-spec.md`
+- ✅ `transform.sh` (implemented)
+- ⏳ `notes.md` (P2)

package/adapters/cursor/SUPPORTED-FEATURES.md

@@ -0,0 +1,90 @@
+# Cursor — supported features
+
+Detailed matrix of which CONDUCTOR features Cursor supports natively.
+
+## Feature support
+
+| Feature | Cursor support | Mechanism | Notes |
+|---|---|---|---|
+| **Always-loaded baseline** | ✅ Native | `.cursorrules` at project root | Auto-loaded in every chat session in the project. |
+| **Per-pattern rule scoping** | ✅ Native | `.cursor/rules/*.mdc` with `globs:` front-matter | Closest analog to Claude's `paths:` lazy-loading. |
+| **Custom slash commands (project)** | ⚠️ Partial | `.cursor/commands/*.md` (where Cursor version supports) | Not as flexible as Claude slash commands; usable but limited. |
+| **MCP servers** | ✅ Native | Cursor settings | Not used by CONDUCTOR; project may add own. |
+| **In-IDE chat / completion** | ✅ Native | Cursor's primary feature set | Inline completion + chat — Cursor's strength. |
+| **Sub-agent dispatch** | ✅ Native (2026) | Custom named agents in `.cursor/agents/*.md` | See `docs/COMPATIBILITY-MATRIX.md` / ADR-031. |
+| **Hooks (stop)** | ✅ Native (2026) | `.cursor/hooks.json` | ADR-031. CONDUCTOR currently emits only the Reflector hook (ADR-032); broader hook-set emission is Phase 2. |
+| **Per-task model routing** | ✅ Native (2026) | Per-agent `model` config in agent definitions | ADR-031. |
+| **Custom agent personas** | ✅ Native (2026) | `.cursor/agents/*.md` named agents | Previously a `.cursorrules` paste-in workaround; now first-class. |
+| **Built-in memory directory** | ❌ | — | DIY at `.memory/` (gitignored). |
+| **In-repo doc templates** | ✅ Native | Plain markdown; Cursor reads on demand | Universal across all adapters. |
+| **Spec-as-you-go ABSOLUTE enforcement** | ❌ rule reminder only | Rule text in `.cursorrules` + `.cursor/rules/spec-as-you-go.mdc` | Self-policed. Pair with pre-commit git hook for mechanical enforcement. |
+| **Two-stage code review enforcement** | ❌ rule reminder only | Rule text reminds; user runs review prompts manually in Cursor chat | |
+
+## Cursor-specific extensions
+
+CONDUCTOR's Cursor adapter MAY install:
+
+- `.cursor/commands/*.md` — project commands for common workflows (e.g., `/plan`, `/review`, `/sync-spec`). These are partial analogs of Claude slash commands.
+
+## Universal-rule → Cursor `.mdc` translation
+
+For each `core/universal-rules/<rule>.md`:
+
+| `core/` front-matter | Cursor `.mdc` front-matter |
+|---|---|
+| `applies_to: ["**/*.ts"]` | `globs:\n  - "**/*.ts"` |
+| `always_loaded: true` | (merge into `.cursorrules` instead of separate `.mdc`) |
+| `priority: 1` | (informational — no Cursor equivalent) |
+
+Cursor `.mdc` accepts:
+```
+---
+description: brief description
+globs:
+  - "<glob1>"
+  - "<glob2>"
+alwaysApply: false
+---
+
+# Rule body
+```
+
+`alwaysApply: true` overrides `globs:` and forces always-on. CONDUCTOR uses this for `spec-as-you-go.mdc` and `token-economy.mdc` (always-on is the safer behavior even though their `applies_to:` in `core/` is `**`).
+
+## Model tier mapping
+
+CONDUCTOR's universal `model-routing.md` rubric describes Opus / Sonnet / Haiku tiers. Cursor users:
+
+- Pick the heaviest model for Plan / Architecture / Large Refactor sessions.
+- Pick the standard model for routine implementation.
+- Pick the cheap model for trivial reads / variable renames.
+
+Cursor's UI exposes the model picker. CONDUCTOR's rule text serves as the rubric for the human's selection.
+
+## What Cursor DOES NOT support (and CONDUCTOR doesn't fake)
+
+> **2026 reconciliation (first-party verified):** the limitations previously listed here are stale. Cursor now natively supports hooks (`.cursor/hooks.json`), sub-agent dispatch with custom named agents (`.cursor/agents/*.md`), per-task model routing (per-agent `model` config), and project commands/skills — see `docs/COMPATIBILITY-MATRIX.md` / ADR-031.
+
+What remains true on the CONDUCTOR side:
+
+- CONDUCTOR does not yet emit a Claude-parity hook set for Cursor. It currently emits only the self-improvement Reflector hook (ADR-032, opt-in — see below). Broader hook-set emission (commit-blocking, spec enforcement) is Phase 2.
+- Until then, commit-blocking enforcement still relies on project-level pre-commit git hooks, and orchestration discipline remains partly a human practice.
+
+## Self-improvement (Reflector) — opt-in
+
+With `--recipes=self-improvement`, the Cursor adapter emits the Reflector loop (ADR-032):
+
+- **Hook**: `.cursor/hooks.json` — registers `.conductor/reflect/trajectory-log.sh` on the `stop` event. Written only if no hook config exists; if one is already present, the adapter emits a manual-merge log entry instead of overwriting.
+- **Command**: `.cursor/skills/reflect/SKILL.md` — the `/reflect` command that distills the trajectory log into lesson candidates.
+- **Agent**: `.cursor/agents/reflector.md` — named reflector agent for the distillation pass.
+- **Scripts**: `.conductor/reflect/trajectory-log.sh` (session trajectory capture) and `.conductor/reflect/prune-lessons.sh` (lesson-file size pruning).
+
+The loop is propose-only — lessons are proposed for human review, never auto-applied to rules. The hook no-ops unless `.conductor/reflect/` exists, so installs without the recipe are unaffected (opt-in gate).
+
+## Verification (deferred to P2)
+
+| Feature claim | Verified-by-real-install | Verification command / observation |
+|---|---|---|
+| `.cursorrules` loads on session start | ⏳ P2 | Open project; new chat; verify rule indicator shows `.cursorrules`. |
+| `.mdc` rules load on file-pattern match | ⏳ P2 | Touch a file matching `globs:`; verify rule indicator. |
+| Project commands work | ⏳ P2 | Type `/<command>` in chat; verify expansion. |

package/adapters/cursor/transform-spec.md

@@ -0,0 +1,124 @@
+# Cursor adapter — transform.sh specification
+
+What `adapters/cursor/transform.sh` MUST do when implemented in P2.
+
+## Invocation
+
+```bash
+./transform.sh <target-dir> [--dry-run]
+```
+
+## Inputs
+
+Reads from (relative to conductor repo root):
+
+```
+core/universal-rules/meta-discipline.md
+core/universal-rules/operations.md
+core/universal-rules/quality-gates.md
+core/universal-rules/spec-as-you-go.md
+core/universal-rules/workflow.md
+core/docs-templates/*.md
+core/docs-templates/specs/_example.md
+core/memory-pattern/README.md
+adapters/cursor/_native/cursorrules.tpl                # Cursor-specific orchestrator manual template
+adapters/cursor/_native/commands/*.md                  # (optional) project commands
+```
+
+## Outputs
+
+```
+<target-dir>/
+├── .cursorrules                                # From _native/cursorrules.tpl + always-loaded rules merged
+├── .cursor/
+│   ├── rules/
+│   │   ├── meta-discipline.mdc                 # Translated (alwaysApply: true)
+│   │   ├── operations.mdc                      # Translated (alwaysApply: true)
+│   │   ├── quality-gates.mdc                   # Translated (alwaysApply: true)
+│   │   ├── spec-as-you-go.mdc                  # Translated (alwaysApply: true)
+│   │   └── workflow.mdc                        # Translated (alwaysApply: true)
+│   └── commands/                                # (optional) project commands
+└── docs/
+    ├── CURRENT_WORK.md                         # Verbatim copy
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## Universal-rules → Cursor `.mdc` translation
+
+For each `core/universal-rules/<rule>.md`:
+
+1. Parse YAML front-matter. Extract `applies_to:`, `always_loaded:`.
+2. If `always_loaded: true`:
+   - APPEND content (sans front-matter, with section heading) to `.cursorrules` "Universal Rules" section.
+   - ALSO emit a `.mdc` with `alwaysApply: true` (Cursor reads both — having both ensures the rule loads even if the user customized `.cursorrules`).
+3. Else:
+   - Emit `.cursor/rules/<rule>.mdc` with translated front-matter:
+     ```yaml
+     ---
+     description: <derived from rule's first paragraph or title>
+     globs:
+       - "<glob1>"
+       - "<glob2>"
+     ---
+     ```
+   - Body content preserved verbatim, except:
+     - `> **Cursor-only mechanism**` callouts: keep as-is.
+     - `> **Claude-only mechanism**` callouts: REPLACE with a degraded callout: `> **Note (Cursor)**: this rule is enforced by hook on Claude Code; on Cursor, follow self-policed.`
+     - Other tool-specific callouts: STRIP.
+
+## Cursor-specific orchestrator manual
+
+`.cursorrules` body:
+
+1. Header — bilingual (한/영) "you are the orchestrator" intro.
+2. The 6 role personas (planner/builder/reviewer/helper/designer/scribe) reformatted as "manual orchestrator personas" — when starting a complex task, paste the relevant persona from this file as your prompt.
+3. ABSOLUTE rules (R1-R8 from CONDUCTOR universal, with R-prefix renumbered for Cursor reality — drop sub-agent-specific rules, keep spec-as-you-go / two-stage review / token economy / model routing).
+4. Universal rule TEXT (from `core/` always-loaded rules).
+5. Pointer to `docs/CURRENT_WORK.md` as session-start read.
+
+## Edge cases
+
+| Case | Adapter behavior |
+|---|---|
+| Target dir doesn't exist | Error to stderr, exit 1. |
+| Target dir is the conductor repo itself | Error to stderr, exit 1. |
+| Existing `.cursorrules` at target | Skip; report "SKIP (exists)". |
+| Existing `.cursor/rules/operations.mdc` | Skip individually. |
+| Cursor version doesn't support `.cursor/commands/` | Skip the commands directory; warn. |
+| Cursor version uses `.cursor/rules.json` instead of `.mdc` | TBD — verify in P2 against the user's Cursor version. |
+
+## Idempotency check
+
+Same as Claude adapter — re-run reports "SKIP (exists)" for everything.
+
+## Verification commands (P2 will fill)
+
+```bash
+test -f "<target>/.cursorrules"                        || echo "MISSING .cursorrules"
+test -d "<target>/.cursor/rules"                       || echo "MISSING .cursor/rules dir"
+test -f "<target>/.cursor/rules/spec-as-you-go.mdc"    || echo "MISSING spec-as-you-go.mdc"
+
+# Open project in Cursor.
+# Touch a docs/specs/*.md file.
+# Verify Cursor rule indicator shows spec-as-you-go.mdc loaded.
+```
+
+## P2 Cursor-version compatibility check
+
+Cursor's rule format has evolved. P2 must verify:
+
+- `.cursor/rules/*.mdc` is the current canonical location (true as of late 2025).
+- `globs:` front-matter is the supported scoping mechanism (true as of late 2025).
+- `alwaysApply: true` is honored.
+
+If any of these have changed by P2 implementation time, document in `adapters/cursor/notes.md` and adjust the spec.
+
+## Out of scope
+
+- Auto-installing Cursor itself.
+- Auto-configuring Cursor settings (privacy mode, model preferences).
+- Per-stack auto-detection.