omniconductor 0.3.0

package/adapters/codex/README.md

@@ -0,0 +1,87 @@
+# Adapter — Codex (T3)
+
+OpenAI Codex (the modern shell-driven agent — not the deprecated original Codex API) is a T3 target because:
+
+- It supports a single project rules file at `AGENTS.md` (project root — the established cross-agent convention).
+- It excels at shell-driven scripting and one-shot tasks.
+
+It is **T3** because:
+
+- ❌ No per-pattern rule scoping.
+- ❌ No sub-agent dispatch.
+- ❌ No hooks.
+- ❌ No per-call model routing.
+- ❌ No built-in memory directory.
+- ⚠️ Limited multi-step orchestration capability vs Claude/Cursor.
+
+**Tier**: T3 — Basic. Rule TEXT installs but most CONDUCTOR mechanism doesn't apply.
+
+## Installation path
+
+```bash
+bash adapters/codex/transform.sh <target>                          # install
+bash adapters/codex/transform.sh <target> --recipes=tdd,debugging  # + opt-in recipes
+bash adapters/codex/transform.sh <target> --dry-run --no-prompt    # preview, write nothing
+bash adapters/codex/transform.sh <target> --uninstall              # revert (manifest-based)
+```
+
+## What gets installed
+
+```
+<target>/
+├── AGENTS.md                                   # Codex-flavored intro + 5 universal rules + compressed workflow + selected recipes + memory note
+└── docs/
+    ├── CURRENT_WORK.md                         # Universal templates
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## Native features supported
+
+- ✅ Always-loaded baseline (`AGENTS.md`).
+- ✅ All universal rule TEXT.
+- ✅ All doc templates.
+- ✅ Strong shell-task execution (Codex's primary strength).
+
+## Features NOT supported
+
+| Feature | Workaround |
+|---|---|
+| Per-pattern rule scoping | All rules always-loaded. |
+| Sub-agent dispatch | Human plays orchestrator (or breaks task into sequential prompts). |
+| Hooks | Pair with project pre-commit git hooks. |
+| Per-call model routing | Single model per Codex invocation. |
+| Built-in memory directory | DIY at `.memory/`. |
+| Multi-step orchestration | Limited — Codex shines at one-shot shell tasks. For multi-step, use Claude/Cursor. |
+
+## Best fit use cases
+
+- Shell scripts.
+- One-shot file transformations.
+- Quick git operations.
+- "Run this command and tell me the output" tasks.
+
+## After install — first steps
+
+1. Verify Codex reads `AGENTS.md` (auto-loaded from project root on session start).
+2. Customize `AGENTS.md` for your project as needed.
+3. Add `.memory/` to `.gitignore`.
+4. Use Codex for shell tasks; rely on Claude/Cursor for multi-step orchestration.
+
+## Quirks / known issues
+
+- Output is `AGENTS.md` at the project root (the established cross-agent convention adopted by
+  OpenAI Codex / Codex CLI), superseding the early-design `.codex/codex.md` guess.
+- Single-file model: everything Cursor splits across `.cursor/rules/*.mdc` is concatenated into
+  `AGENTS.md`. All rules are always-on — Codex has no per-pattern scoping.
+
+## Status
+
+- ✅ `README.md`
+- ✅ `SUPPORTED-FEATURES.md`
+- ✅ `transform-spec.md`
+- ✅ `transform.sh` (implemented — single-file `AGENTS.md` bundle, recipes, dry-run, manifest-based uninstall)
+- ⏳ `notes.md` (real-Codex install verification deferred)

package/adapters/codex/SUPPORTED-FEATURES.md

@@ -0,0 +1,66 @@
+# Codex — supported features
+
+Detailed matrix of which CONDUCTOR features Codex supports.
+
+## Feature support
+
+| Feature | Codex support | Mechanism | Notes |
+|---|---|---|---|
+| **Always-loaded project rules** | ✅ Native | `AGENTS.md` | Auto-loaded by Codex on session start. |
+| **Shell task execution** | ✅ Strength | Codex's primary capability | One-shot shell scripting is Codex's best use case. |
+| **Per-pattern rule scoping** | ❌ | — | All rules always-loaded. |
+| **Sub-agent dispatch** | ✅ Native (2026) | Custom named agents in `.codex/agents/*.toml` | See `docs/COMPATIBILITY-MATRIX.md` / ADR-031. |
+| **Hooks (Stop etc.)** | ✅ Native (2026) | `.codex/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 TOML | ADR-031. |
+| **Custom slash commands** | ✅ Native (2026) | Skills at `.agents/skills/*/SKILL.md` | ADR-031. |
+| **Built-in memory directory** | ❌ | — | DIY at `.memory/`. |
+| **In-repo doc templates** | ✅ Universal | Plain markdown | Read on demand. |
+| **Spec-as-you-go ABSOLUTE enforcement** | ❌ rule reminder only | Rule text in `AGENTS.md` reminds | Self-policed. |
+| **Two-stage code review enforcement** | ❌ rule reminder only | | |
+| **Multi-step orchestration** | ⚠️ Limited | Sequential prompts | For complex multi-step work, prefer Claude/Cursor. |
+
+## Universal-rule → Codex bundle translation
+
+For each `core/universal-rules/<rule>.md`:
+
+1. Strip front-matter (Codex doesn't use it).
+2. Concatenate body into `AGENTS.md` as a section with heading `## <rule name>`.
+3. Tool-specific callouts:
+   - `> **Codex-only mechanism**` (rare): keep.
+   - `> **Claude-only mechanism**`: REPLACE with `> **Note (Codex)**: enforced by hook on Claude Code; on Codex, follow self-policed.`
+   - Other tool callouts: STRIP.
+
+## Strengths to lean into
+
+- One-shot shell tasks (the orchestrator role isn't really meaningful here).
+- The `AGENTS.md` rule bundle gives Codex enough context to follow project conventions for code it generates inline.
+
+## Weaknesses to acknowledge
+
+- Multi-step orchestration is awkward in Codex. Consider Codex a "specialist" tool — use it for shell tasks; use Claude/Cursor for the orchestrator workflow.
+- Bundled rules approach the context limit faster on smaller models. If `AGENTS.md` becomes too large, consider trimming the workflow phase definitions (keep universal rules + ABSOLUTE rules).
+
+## transform.sh status
+
+✅ **Implemented.** `adapters/codex/transform.sh` emits a single-file `AGENTS.md` bundle (Codex-flavored
+bilingual intro + ABSOLUTE-rules summary + 5 universal rules sans frontmatter + compressed workflow +
+opt-in recipes + DIY `.memory/` note) plus universal `docs/` templates. Supports `--recipes=`,
+`--dry-run`, `--no-prompt`, and manifest-based `--uninstall`/`--force`. Output target is `AGENTS.md`
+at the project root (the established cross-agent convention), not the early-design `.codex/codex.md`.
+
+## Self-improvement (Reflector) — opt-in
+
+With `--recipes=self-improvement`, the Codex adapter emits the Reflector loop (ADR-032):
+
+- **Hook**: `.codex/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**: `.agents/skills/reflect/SKILL.md` — the `/reflect` skill that distills the trajectory log into lesson candidates.
+- **Agent**: `.codex/agents/reflector.toml` — 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 (real-Codex install deferred)
+
+| Feature claim | Verified-by-real-install | Verification command / observation |
+|---|---|---|
+| `AGENTS.md` auto-loads | ⏳ deferred | Run Codex in project; verify it cites project conventions. |

package/adapters/codex/transform-spec.md

@@ -0,0 +1,90 @@
+# Codex adapter — transform.sh specification
+
+What `adapters/codex/transform.sh` MUST do when implemented in P3.5.
+
+## 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/codex/_native/codex.md.tpl              # Header template (Codex-flavored intro)
+```
+
+## Outputs
+
+> **Convention change (post-P0):** the canonical Codex project-rules file is **`AGENTS.md`** at the
+> project root — the established cross-agent standard adopted by OpenAI Codex / Codex CLI — NOT the
+> early-design `.codex/codex.md` guess. The implemented `transform.sh` emits `AGENTS.md`; references
+> to `.codex/codex.md` below are retained as historical design notes only.
+
+```
+<target-dir>/
+├── AGENTS.md                                   # Bundled all-rules + workflow + intro (project root)
+└── docs/
+    ├── CURRENT_WORK.md                         # Verbatim
+    ├── REMAINING_TASKS.md
+    ├── PLANS.md
+    ├── TASKS.md
+    ├── INDEX.md
+    └── specs/_example.md
+```
+
+## `.codex/codex.md` composition (in order)
+
+1. **Header from `_native/codex.md.tpl`** — bilingual (한/영) intro adapted for Codex (one-shot model, shell-task strength).
+2. **ABSOLUTE rules section** — R1-R8 minus Claude-only sub-agent enforcement. R-prefix renumbered.
+3. **Universal rules section** — for each `core/universal-rules/<rule>.md`:
+   - Heading: `## <rule title>`
+   - Body: rule content sans front-matter.
+4. **Workflow section** — compressed version of `core/workflow/PHASES.md` (Codex's typical use cases skip Plan/Architecture more often than other tools).
+5. **Pointer to docs** — `Read docs/CURRENT_WORK.md before any non-trivial task.`
+6. **Note on memory** — explain DIY `.memory/`.
+
+## Universal-rules → Codex bundle translation
+
+Same as Gemini adapter — strip front-matter, concatenate, replace tool-specific callouts.
+
+## Edge cases
+
+| Case | Adapter behavior |
+|---|---|
+| `.codex/` doesn't exist | Create it. |
+| Existing `.codex/codex.md` | Skip; report "SKIP (exists)". |
+| `.codex/codex.md` exceeds Codex context budget | Warn; document trim strategy in `notes.md`. |
+
+## Idempotency check
+
+Re-run reports "SKIP (exists)" for everything.
+
+## Verification commands (P3.5 will fill)
+
+```bash
+test -f "<target>/.codex/codex.md"                     || echo "MISSING codex.md"
+
+# Run Codex in <target>; verify it follows ABSOLUTE rules + universal conventions.
+```
+
+## P3.5 Codex version compatibility check
+
+- Confirm `.codex/codex.md` IS the canonical project-rules location.
+- Confirm Codex auto-loads it on session start.
+- Confirm Codex follows the rule TEXT in its inline code generation.
+
+If Codex has changed conventions by P3.5, document in `notes.md`.
+
+## Out of scope
+
+- Codex authentication / API key.
+- Per-stack auto-detection.