omniconductor 0.3.0

package/adapters/copilot/README.md

@@ -0,0 +1,88 @@
+# Adapter — GitHub Copilot (T2)
+
+GitHub Copilot is a T2 target because:
+
+- It supports per-pattern rule scoping via `.github/instructions/*.instructions.md` `applyTo:` front-matter.
+- Instructions live IN the repo, so all collaborators automatically share them.
+- Copilot's PR review feature provides a partial Stage B code-review analog tied to GitHub.
+
+It is **T2 (not T1)** because:
+
+- ❌ No sub-agent dispatch.
+- ❌ No hooks for ABSOLUTE enforcement.
+- ❌ No per-call model routing (model picker in UI).
+- ❌ No built-in memory directory.
+- ⚠️ Slash commands limited.
+
+**Tier**: T2 — Good support; rule scoping works well, enforcement is limited.
+
+## Installation path
+
+```bash
+# Install (the copilot adapter is implemented):
+bash /path/to/conductor/adapters/copilot/transform.sh /path/to/target [--dry-run]
+
+# (planned / roadmap — not yet available):
+# npx omniconductor init --target=copilot [target-dir]
+```
+
+## What gets installed
+
+```
+<target>/
+├── .github/
+│   └── instructions/
+│       ├── all.instructions.md                 # applyTo: '**' (always-loaded)
+│       ├── operations.instructions.md          # applyTo: '**'
+│       ├── coding-conventions.instructions.md  # applyTo: '**/*.{ts,tsx,js,jsx}'
+│       ├── token-economy.instructions.md       # applyTo: '**'
+│       ├── spec-as-you-go.instructions.md      # applyTo: 'docs/specs/**,**/*.md'
+│       └── model-routing.instructions.md       # applyTo: '**'
+└── docs/
+    ├── CURRENT_WORK.md                         # Universal templates
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## Native features supported
+
+- ✅ Always-loaded baseline (`applyTo: '**'`).
+- ✅ Per-pattern rule scoping (`applyTo:` front-matter).
+- ✅ Instructions IN the repo (collaborator-shared).
+- ✅ All universal rule TEXT.
+- ✅ All doc templates.
+- ⚠️ Copilot PR review feature for Stage B (partial).
+
+## Features NOT supported
+
+| Feature | Workaround |
+|---|---|
+| Sub-agent dispatch | Human plays orchestrator role. |
+| Hooks | Pair with project-level pre-commit git hooks for enforcement. |
+| Per-call model routing | Pick model in Copilot Chat UI. |
+| Built-in memory directory | DIY at `.memory/` (gitignored). |
+| Specialized review agents (Stage A) | Run review prompts manually in Copilot Chat. Use Copilot PR review for Stage B (best-effort). |
+
+## After install — first steps
+
+1. Commit `.github/instructions/` to your repo. All collaborators automatically pick up the rules.
+2. Configure Copilot PR review for Stage B (in repo settings).
+3. Customize the always-loaded section of `all.instructions.md` — replace `{{PROJECT_NAME}}`.
+4. Rename `docs/specs/_example.md` → `docs/specs/<your-area>.md`.
+5. Add `.memory/` to `.gitignore`. Create your first memory entry.
+
+## Quirks / known issues (P3 will fill)
+
+- TBD: Copilot's `applyTo:` glob syntax differs slightly from Cursor's `globs:`. P3 verifies the exact dialect.
+- TBD: Copilot Chat's instruction-loading order when multiple files match.
+
+## Status (P0 foundation)
+
+- ✅ `README.md`
+- ✅ `SUPPORTED-FEATURES.md`
+- ✅ `transform-spec.md`
+- ✅ `transform.sh` (implemented)
+- ⏳ `notes.md` (P3)

package/adapters/copilot/SUPPORTED-FEATURES.md

@@ -0,0 +1,73 @@
+# GitHub Copilot — supported features
+
+Detailed matrix of which CONDUCTOR features Copilot supports natively.
+
+## Feature support
+
+| Feature | Copilot support | Mechanism | Notes |
+|---|---|---|---|
+| **Always-loaded baseline** | ✅ Native | `.github/instructions/*.instructions.md` with `applyTo: '**'` | Loaded for every Copilot Chat session in the repo. |
+| **Per-pattern rule scoping** | ✅ Native | `applyTo:` front-matter (CSV glob list) | Closest analog to Claude `paths:` and Cursor `globs:`. |
+| **Instructions IN the repo** | ✅ Native | `.github/instructions/` is committed to the repo | All collaborators automatically share rules. Strong feature. |
+| **Inline completion + chat** | ✅ Native | Copilot's primary feature | |
+| **PR review automation** | ✅ Native | Copilot's PR review feature (configurable per repo) | Useful Stage B analog. |
+| **MCP servers** | ⚠️ Partial | Copilot has limited MCP support depending on version | CONDUCTOR doesn't depend; project may add own. |
+| **Sub-agent dispatch** | ✅ Native (2026) | Custom named agents in `.github/agents/*.agent.md` | See `docs/COMPATIBILITY-MATRIX.md` / ADR-031. |
+| **Hooks (agentStop)** | ✅ Native (2026) | `.github/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` in agent front-matter | ADR-031. |
+| **Custom slash commands** | ✅ Native (2026) | Prompt files at `.github/prompts/*.prompt.md` | Was unavailable as of late 2025; supported now (ADR-031). |
+| **Built-in memory directory** | ❌ | — | DIY at `.memory/` (gitignored). |
+| **In-repo doc templates** | ✅ Universal | Plain markdown; Copilot Chat reads on demand | |
+| **Spec-as-you-go ABSOLUTE enforcement** | ❌ rule reminder only | Rule in `.instructions.md` with `applyTo: 'docs/specs/**,**/*.md'` reminds when relevant files are touched | Self-policed. |
+| **Two-stage code review enforcement** | ⚠️ Partial | Stage A: rule reminder; Stage B: configure Copilot PR review feature | |
+
+## Universal-rule → Copilot `.instructions.md` translation
+
+For each `core/universal-rules/<rule>.md`:
+
+| `core/` front-matter | Copilot `.instructions.md` front-matter |
+|---|---|
+| `applies_to: ["**/*.ts", "**/*.tsx"]` | `applyTo: '**/*.ts,**/*.tsx'` (CSV) |
+| `always_loaded: true` | `applyTo: '**'` (matches everything) |
+
+Copilot accepts:
+```
+---
+applyTo: '<csv-glob-list>'
+---
+
+# Rule body in plain markdown
+```
+
+## What Copilot DOES NOT support
+
+> **2026 reconciliation (first-party verified):** most limitations previously listed here are stale. Copilot now natively supports hooks (`.github/hooks/*.json`), sub-agent dispatch with custom named agents (`.github/agents/*.agent.md`), per-task model routing (per-agent `model`), and project-level commands via prompt files (`.github/prompts/*.prompt.md`) — see `docs/COMPATIBILITY-MATRIX.md` / ADR-031.
+
+Still true:
+
+- No built-in memory directory — DIY at `.memory/` (gitignored).
+- CONDUCTOR does not yet emit a Claude-parity hook set for Copilot. 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, pair with project pre-commit git hooks.
+
+## Strengths to lean into
+
+- **`.github/instructions/` shared with the team automatically** — no per-developer setup. This is Copilot's strongest feature for CONDUCTOR.
+- **PR review feature** — partial Stage B replacement. Configure to auto-review on PR open.
+
+## Self-improvement (Reflector) — opt-in
+
+With `--recipes=self-improvement`, the Copilot adapter emits the Reflector loop (ADR-032):
+
+- **Hook**: `.github/hooks/conductor-reflect.json` — registers `.conductor/reflect/trajectory-log.sh` on the `agentStop` event. Written only if absent; if a hook config already exists, the adapter emits a manual-merge log entry instead of overwriting.
+- **Command**: `.github/prompts/reflect.prompt.md` — the `/reflect` prompt that distills the trajectory log into lesson candidates.
+- **Agent**: `.github/agents/reflector.agent.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 P3)
+
+| Feature claim | Verified-by-real-install | Verification command / observation |
+|---|---|---|
+| `.instructions.md` files load in Copilot Chat | ⏳ P3 | Open project; check Copilot Chat shows file references. |
+| `applyTo:` per-pattern scoping works | ⏳ P3 | Open file matching `applyTo:`; verify rule loads. |
+| PR review uses CONDUCTOR rules | ⏳ P3 | Open PR; check review references `coding-conventions`. |

package/adapters/copilot/transform-spec.md

@@ -0,0 +1,111 @@
+# GitHub Copilot adapter — transform.sh specification
+
+What `adapters/copilot/transform.sh` MUST do when implemented in P3.
+
+## Invocation
+
+```bash
+./transform.sh <target-dir> [--dry-run]
+```
+
+## Inputs
+
+```
+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/copilot/_native/all.instructions.tpl       # Always-loaded baseline template
+```
+
+## Outputs
+
+```
+<target-dir>/
+├── .github/
+│   ├── copilot-instructions.md                  # DEFAULT: 5 universal rules concatenated (repo-wide)
+│   └── instructions/                            # --per-rule mode and/or selected recipes
+│       ├── meta-discipline.instructions.md      # applyTo: '**'  (only in --per-rule mode)
+│       ├── operations.instructions.md           # applyTo: '**'  (only in --per-rule mode)
+│       ├── quality-gates.instructions.md        # applyTo: '**'  (only in --per-rule mode)
+│       ├── spec-as-you-go.instructions.md       # applyTo: '**'  (only in --per-rule mode)
+│       └── workflow.instructions.md             # applyTo: '**'  (only in --per-rule mode)
+└── docs/
+    ├── CURRENT_WORK.md                          # Verbatim
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## Universal-rules → Copilot `.instructions.md` translation
+
+For each `core/universal-rules/<rule>.md`:
+
+1. Parse YAML front-matter. Extract `applies_to:`, `always_loaded:`.
+2. Translate `applies_to:` array → CSV string for `applyTo:` (Copilot uses CSV glob syntax).
+3. If `always_loaded: true` → emit with `applyTo: '**'`.
+4. Else → emit with `applyTo: '<csv>'`.
+5. Body content preserved verbatim, except:
+   - `> **Copilot-only mechanism**` callouts: keep as-is.
+   - `> **Claude-only mechanism**` callouts: REPLACE with degraded callout: `> **Note (Copilot)**: enforced by hook on Claude Code; on Copilot, follow self-policed.`
+   - Other tool-specific callouts: STRIP.
+
+## Repo-wide baseline (`.github/copilot-instructions.md`)
+
+In the default mode, the 5 universal rules are concatenated (body only) into `.github/copilot-instructions.md`. Body composition (in order):
+
+1. Header: orchestrator manual intro adapted for Copilot Chat (single-session, no sub-agents).
+2. ABSOLUTE rules (R1-R8 minus sub-agent-specific R1, plus a Copilot-specific note about PR review for Stage B).
+3. All universal-rule content where `always_loaded: true`.
+4. Pointer to `docs/CURRENT_WORK.md` as session-start read.
+
+Maximum size guidance: keep ≤ 1500 lines (Copilot has context limits; check Copilot's current docs for exact limit at P3 implementation time).
+
+## Copilot-specific extensions
+
+- Configure suggested PR review settings as a `notes.md` post-install instruction (not auto-configured — requires repo admin action).
+
+## Edge cases
+
+| Case | Adapter behavior |
+|---|---|
+| `.github/` doesn't exist | Create it. |
+| Existing `.github/copilot-instructions.md` | Skip; report "SKIP (exists)". |
+| Existing `.github/instructions/<rule>.instructions.md` | Skip individually. |
+| Glob patterns contain commas (Copilot uses CSV) | Properly escape; warn if any pattern itself contains comma. |
+
+## Idempotency check
+
+Re-run reports "SKIP (exists)" for everything.
+
+## Verification commands (P3 will fill)
+
+```bash
+test -f "<target>/.github/copilot-instructions.md"                   || echo "MISSING copilot-instructions.md"
+# --per-rule mode:
+# test -f "<target>/.github/instructions/spec-as-you-go.instructions.md" || echo "MISSING spec-as-you-go"
+
+# Open Copilot Chat in project; ask "what rules apply?"; verify list.
+# Touch a docs/specs/*.md file; ask Copilot for guidance; verify spec-as-you-go content surfaces.
+```
+
+## P3 Copilot version compatibility check
+
+Verify against the user's Copilot version:
+- `.github/instructions/*.instructions.md` is the canonical location.
+- `applyTo:` uses CSV glob syntax (verify exact syntax — comma-separated vs YAML list).
+- Multiple matching files compose (additive) rather than override.
+
+If Copilot has changed format by P3, document in `notes.md`.
+
+## Out of scope
+
+- Auto-configuring Copilot PR review (requires repo admin permissions).
+- Per-stack auto-detection.
+- VS Code / JetBrains editor settings.