@ngockhoale/ukit 2.1.5 → 2.2.2

package/templates/.claude/commands/ukit/handoff-create.md

@@ -1,11 +1,13 @@
 # /ukit:handoff-create — Phase 1 + 2: Plan
 
 **Role: PLANNER**
-**Tool: any** (Claude Code / Codex / Antigravity / Kilo / OpenCode — your choice)
+**Tool: any** (Claude Code / Codex / omp / Kilo / OpenCode — your choice)
 **Model split:**
 - Read/understand → lite model (haiku · unic-lite · cheapest available)
 - Write plan + tasks → strong model (Opus · unic-smart · strongest available)
 
+> **omp model tiers:** the tiers above map to `.omp/config.yml`'s `modelRoles`, referenced from agent frontmatter as `@lite` / `@code` / `@smart`.
+
 ## Problem / feature
 $ARGUMENTS
 
@@ -20,7 +22,7 @@ Planning is the **only** place in the handoff pipeline where asking the human is
 it is where every ambiguity must be burned off. Whatever is left unresolved here becomes a
 guess during implementation, where nobody is available to correct it.
 
-**Ask once, up front, batched.** Before Step 1, if `$ARGUMENTS` leaves a choice that changes
+**Ask once, up front, batched.** Before Step 1, if the **Problem / feature** section above leaves a choice that changes
 *what gets built* — not how — collect every such question into a **single** `AskUserQuestion`
 call (max 4 questions, each with a `(Recommended)` first option). Then close the window.
 
@@ -39,7 +41,7 @@ After the batched call, run Steps 1–2.5 to completion without further question
 
 ## Step 1 — Read context (lite model)
 
-**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"`. Do NOT read these files yourself in the current session — this step is contracted to the lite tier (haiku/unic-lite), which only the spawned agent's frontmatter model guarantees. Ask the agent to:
+**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`). Do NOT read these files yourself in the current session — this step is contracted to the lite tier (haiku/unic-lite), which only the spawned agent's frontmatter model guarantees. Ask the agent to:
 
 1. Read `docs/AI_HANDOFF/INDEX.md` → current tasks + statuses (or "empty")
 2. Read `docs/AI_HANDOFF/ACTIVE.md` → active cycle info (or "no active cycle")
@@ -47,13 +49,13 @@ After the batched call, run Steps 1–2.5 to completion without further question
 4. Read `docs/AI_HANDOFF/tasks/_TEMPLATE.md` → task file structure
 5. Return a compact summary. Do NOT write anything yet.
 
-> Other tools without subagent support: manually switch to the lite model, run the steps above yourself, keep the summary in context.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the lite model, run the steps above yourself, keep the summary in context.
 
 ---
 
 ## Step 2 — Write plan + tasks (strong model)
 
-**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "handoff-planner"`, passing it the Step 1 summary and the problem/feature description. Do NOT write PLAN.md or task files yourself in the current session — this step is contracted to the strong tier (opus/unic-smart), which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "handoff-planner"` (omp: the `task` tool with `agent: "handoff-planner"`), passing it the Step 1 summary and the problem/feature description. Do NOT write PLAN.md or task files yourself in the current session — this step is contracted to the strong tier (opus/unic-smart), which only the spawned agent's frontmatter model guarantees.
 
 The planner agent does the following (use Step 1 summary — do NOT re-read files):
 
@@ -104,7 +106,7 @@ The planner agent does the following (use Step 1 summary — do NOT re-read file
 
 7. Report: task IDs, dependency graph, any `needs_breakdown` + reason
 
-> Other tools without subagent support: manually switch to the strong model, execute steps 1–7 above yourself.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the strong model, execute steps 1–7 above yourself.
 
 ---
 
@@ -119,13 +121,13 @@ The planner agent does the following (use Step 1 summary — do NOT re-read file
 Two independent strong-model passes shape the plan before any code is written — that gate is
 intact. What it no longer does is hand a stalled plan back and wait.
 
-**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "code-reviewer"`, passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from Step 2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
+**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "code-reviewer"` (omp: the `task` tool with `agent: "code-reviewer"`), passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from Step 2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
 
 1. Reviewer reads `PLAN.md` only (no diff, no task files, no executor report), checks Completeness / Consistency / Clarity / Scope / YAGNI — see `.claude/agents/code-reviewer.md` → Spec/Plan Review — and appends its verdict to PLAN.md's `## Plan Review Log` (new round entry, prior rounds kept).
 2. `Issues Found` → route back to Step 2: planner revises `PLAN.md` and the affected `TASK-xxx.md` files to address every finding, then re-submit for another Step 2.5 review (this becomes the next round). Do NOT commit or hand off to executor on `Issues Found`.
 3. `Approved` → append `PLAN_REVIEW: Approved by <reviewer model>` to PLAN.md's `## Planner Report` footer, then proceed.
 
-> Other tools without subagent support: manually switch to the strong model in a **separate** chat/session from Step 2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the strong model in a **separate** chat/session from Step 2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
 
 ---
 

package/templates/.claude/commands/ukit/handoff-fullstack.md

@@ -1,7 +1,7 @@
 # /ukit:handoff-fullstack — Full Pipeline: Plan → Implement → Review
 
 **Role: ORCHESTRATOR**
-**Tool: any** (Claude Code / Codex / Kilo / OpenCode — your choice)
+**Tool: any** (Claude Code / Codex / omp / Kilo / OpenCode — your choice)
 
 ## Model Split
 
@@ -12,23 +12,27 @@
 | Planning + Review (reasoning, design, verification) | opus · unic-smart · strongest available |
 
 > Claude Code: spawn `ukit-small-task-maintainer` (haiku) for light steps; spawn `handoff-planner` (opus) for planning; spawn `feature-implementer` (sonnet) agents for implementation; spawn `code-reviewer` (opus) per task for review.
+>
+> omp: same four agents, launched with the `task` tool (`agent: "<name>"`). They live in `.omp/agents/` and bind their tier through `model: "@lite"` / `"@code"` / `"@smart"`, resolved via `modelRoles` in `.omp/config.yml` — you do not pass a model name.
+
+> **omp model tiers:** the tiers above map to `.omp/config.yml`'s `modelRoles`, referenced from agent frontmatter as `@lite` / `@code` / `@smart`.
 
 ---
 
 ## Problem / feature
 $ARGUMENTS
 
-> **If `$ARGUMENTS` is empty:** Do NOT proceed. Ask the user: "What problem or feature would you like to tackle in this handoff cycle? Please describe it in one or more sentences." Wait for the answer before running any phase.
+> **If the **Problem / feature** section above is empty:** Do NOT proceed. Ask the user: "What problem or feature would you like to tackle in this handoff cycle? Please describe it in one or more sentences." Wait for the answer before running any phase.
 
 ---
 
 ## Autonomy Contract — read before anything else
 
 This command is a **one-shot pipeline**. The human is not watching. Treat every phase below
-as unattended: they may walk away after submitting `$ARGUMENTS` and come back to a finished
+as unattended: they may walk away after submitting the request and come back to a finished
 result.
 
-**The single question window is P0, before any file is written.** If `$ARGUMENTS` leaves a
+**The single question window is P0, before any file is written.** If the **Problem / feature** section above leaves a
 choice that would change what gets built — not how it gets built — batch every such question
 into **one** `AskUserQuestion` call (max 4 questions, each with a `(Recommended)` first
 option) and resolve them all at once. Record the answers in `PLAN.md` §1.
@@ -60,7 +64,7 @@ numbered step completes:
 
 ```
 Command: handoff-fullstack
-Goal: <one sentence from $ARGUMENTS>
+Goal: <one sentence from the **Problem / feature** section above>
 Base: <BASE branch>
 Phase: <P1|P2|P2.5|P3|I1|I2|I3|I4|R1|R2|R3|R4|R5|done>
 Cursor: wave <N> batch <M> — <what just finished>
@@ -78,7 +82,7 @@ continue. Read the cursor, then jump straight to `Next:` and carry on. Tasks alr
 or `pending_review` are skipped; only `ready`, `in_progress`, `changes_requested` and
 `blocked` tasks are picked up.
 
-Only when `RUN.md` is absent or `Phase: done` does `$ARGUMENTS` start a fresh cycle.
+Only when `RUN.md` is absent or `Phase: done` does a new request start a fresh cycle.
 
 ---
 
@@ -86,7 +90,7 @@ Only when `RUN.md` is absent or `Phase: done` does `$ARGUMENTS` start a fresh cy
 
 ### P1 — Read context (lite model)
 
-**Claude Code — MANDATORY, do this before anything else in P1:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"`. Do NOT read these files yourself in the current session — this step is contracted to the lite tier (haiku/unic-lite), which only the spawned agent's frontmatter model guarantees. Ask it to return a compact summary of:
+**Claude Code — MANDATORY, do this before anything else in P1:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`). Do NOT read these files yourself in the current session — this step is contracted to the lite tier (haiku/unic-lite), which only the spawned agent's frontmatter model guarantees. Ask it to return a compact summary of:
 
 1. `docs/AI_HANDOFF/INDEX.md` — current tasks + statuses (or "empty / no tasks")
 2. `docs/AI_HANDOFF/ACTIVE.md` — active cycle info (or "no active cycle")
@@ -95,11 +99,11 @@ Only when `RUN.md` is absent or `Phase: done` does `$ARGUMENTS` start a fresh cy
 
 Return a compact summary. Do NOT write any files yet.
 
-> Other tools without subagent support: manually switch to the lite model and run P1 yourself.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the lite model and run P1 yourself.
 
 ### P2 — Write PLAN.md + task files (strong model)
 
-**Claude Code — MANDATORY, do this before anything else in P2:** call the Agent tool with `subagent_type: "handoff-planner"`, passing it the P1 summary and `$ARGUMENTS`. Do NOT write PLAN.md or task files yourself in the current session — this step is contracted to the strong tier (opus/unic-smart), which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else in P2:** call the Agent tool with `subagent_type: "handoff-planner"` (omp: the `task` tool with `agent: "handoff-planner"`), passing it the P1 summary and the **Problem / feature** section above. Do NOT write PLAN.md or task files yourself in the current session — this step is contracted to the strong tier (opus/unic-smart), which only the spawned agent's frontmatter model guarantees.
 
 The planner agent does the following (use P1 summary — do NOT re-read files):
 
@@ -160,24 +164,24 @@ The planner agent does the following (use P1 summary — do NOT re-read files):
 The gate still does its job — two independent opus passes shape the plan before a line of code
 is written. What it no longer does is hand a stalled plan back to a human who isn't there.
 
-**Claude Code — MANDATORY, do this before anything else in P2.5:** call the Agent tool with `subagent_type: "code-reviewer"`, passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from P2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
+**Claude Code — MANDATORY, do this before anything else in P2.5:** call the Agent tool with `subagent_type: "code-reviewer"` (omp: the `task` tool with `agent: "code-reviewer"`), passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from P2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
 
 1. Reviewer reads `PLAN.md` only (no diff, no task files, no executor report), checks Completeness / Consistency / Clarity / Scope / YAGNI — see `.claude/agents/code-reviewer.md` → Spec/Plan Review — and appends its verdict to PLAN.md's `## Plan Review Log` (new round entry, prior rounds kept).
 2. `Issues Found` → route back to P2: `handoff-planner` revises `PLAN.md` and the affected `TASK-xxx.md` files to address every finding, then re-submit for one more P2.5 review round — subject to the loop cap above.
 3. `Approved` → append `PLAN_REVIEW: Approved by <reviewer model>` to PLAN.md's `## Planner Report` footer, then proceed to P3.
 
-> Other tools without subagent support: manually switch to the strong model in a **separate** chat/session from P2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the strong model in a **separate** chat/session from P2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
 
 ### P3 — Commit the plan (lite model)
 
-**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` for this commit step (lite tier — haiku/unic-lite). Run:
+**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`) for this commit step (lite tier — haiku/unic-lite). Run:
 ```bash
 git add docs/AI_HANDOFF/ && git commit -m "handoff: plan — <goal>"
 ```
 
 Replace `<goal>` with the one-sentence goal from ACTIVE.md. This locks the plan in git before any implementation begins.
 
-> Other tools without subagent support: manually switch to the lite model for P2/P3.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the lite model for P2/P3.
 
 ---
 
@@ -185,7 +189,7 @@ Replace `<goal>` with the one-sentence goal from ACTIVE.md. This locks the plan
 
 ### I1 — Setup + verify (lite model)
 
-**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` for I1. Ask it to read:
+**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`) for I1. Ask it to read:
 - `docs/AI_HANDOFF/ACTIVE.md` → get `Base: <BASE>`
 - `docs/AI_HANDOFF/INDEX.md` → collect all `ready` tasks
 
@@ -234,7 +238,7 @@ leaves worktrees behind. Batching only ever narrows a wave, never reorders acros
 
 ### I3 — Execute wave by wave (code model agents)
 
-**Claude Code — MANDATORY, do this before anything else in I3:** for each wave, call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents`), each with `subagent_type: "feature-implementer"`. Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else in I3:** for each wave, call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents`), each with `subagent_type: "feature-implementer"` (omp: the `task` tool with `agent: "feature-implementer"`, likewise invoked once per task in the batch, not once per wave). Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
 
 For each wave:
 
@@ -356,7 +360,7 @@ logs used to cost. That difference is what makes a multi-wave cycle finish in on
 
 ### I4 — Consolidate + update INDEX (lite model)
 
-**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` for I4. After all waves complete, ask it to:
+**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`) for I4. After all waves complete, ask it to:
 
 1. Update `docs/AI_HANDOFF/INDEX.md`:
    - PASS tasks → `pending_review`
@@ -376,7 +380,7 @@ logs used to cost. That difference is what makes a multi-wave cycle finish in on
 
 ### R1 — Setup (lite model)
 
-**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` for the R1 reads. Ask it to read:
+**Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` (omp: the `task` tool with `agent: "ukit-small-task-maintainer"`) for the R1 reads. Ask it to read:
 - `docs/AI_HANDOFF/ACTIVE.md` → get `Base: <BASE>`
 - `docs/AI_HANDOFF/INDEX.md` → collect `pending_review` tasks
 
@@ -400,7 +404,7 @@ If that diff is empty → implement was not completed. Do not stop: re-enter Pha
 
 **Batch the review set — mandatory.** Read `handoff.maxParallelAgents` from `.ukit/storage/config.json`. If more `pending_review` tasks exist than that, split into consecutive batches of at most that many; finish one batch's verdicts (R2–R4, appended to each task file) before starting the next.
 
-**Claude Code — MANDATORY, do this before anything else in R2–R4:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"`. Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else in R2–R4:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"` (omp: the `task` tool with `agent: "code-reviewer"`, likewise invoked once per task in the batch, not once per wave). Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees.
 
 The spawned reviewer agent reads `EXECUTOR_MODEL` from each task file `## Executor Report`:
 

package/templates/.claude/commands/ukit/handoff-implement.md

@@ -1,9 +1,11 @@
 # /ukit:handoff-implement — Phase 3: Execute
 
 **Role: EXECUTOR (orchestrated)**
-**Tool: any** (Claude Code / Codex / Antigravity / Kilo / OpenCode — your choice)
+**Tool: any** (Claude Code / Codex / omp / Kilo / OpenCode — your choice)
 **Model: code model** (Sonnet · unic-code · cheap-smart)
 
+> **omp model tiers:** the tiers above map to `.omp/config.yml`'s `modelRoles`, referenced from agent frontmatter as `@lite` / `@code` / `@smart`.
+
 ## Target (optional)
 $ARGUMENTS
 _Empty = all `ready` tasks. Or: "TASK-001" for a specific task._
@@ -56,7 +58,7 @@ If this file already exists with `Phase:` not `done` when the command starts, th
 ## Step 1 — Setup
 
 Read `docs/AI_HANDOFF/ACTIVE.md` → get `Base: <BASE>`.
-Read `docs/AI_HANDOFF/INDEX.md` → collect `ready` tasks (or specific task from $ARGUMENTS).
+Read `docs/AI_HANDOFF/INDEX.md` → collect `ready` tasks (or the specific task named in the request above).
 If there are no `ready` tasks, check for `changes_requested`/`blocked` ones and run those
 instead. Only if nothing is actionable → report and stop.
 
@@ -117,7 +119,7 @@ git worktree add -b handoff/task-xxx .worktrees/task-xxx $BASE
 
 ### 3b — Run tasks in parallel (one agent/session per task)
 
-**Claude Code — MANDATORY, do this before anything else in this wave:** call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents`), each with `subagent_type: "feature-implementer"`. Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else in this wave:** call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents`), each with `subagent_type: "feature-implementer"` (omp: the `task` tool with `agent: "feature-implementer"`, likewise invoked once per task in the batch, not once per wave). Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
 
 Each spawned agent works independently in its own worktree — **NO git commit, NO git add**:
 
@@ -161,7 +163,7 @@ disk in the task file, which is where the reviewer reads them from. Pasting them
 second time is what blows up the orchestrator's context window and kills the run mid-wave.
 ```
 
-> Other tools without subagent support: open each task in a separate session with the code model.
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** open each task in a separate session with the code model.
 
 ### 3c — Orchestrator: copy changes to main + IMMEDIATELY delete worktree
 

package/templates/.claude/commands/ukit/handoff-review.md

@@ -1,9 +1,11 @@
 # /ukit:handoff-review — Phase 4: Review
 
 **Role: REVIEWER**
-**Tool: any** (Claude Code / Codex / Antigravity / Kilo / OpenCode — your choice)
+**Tool: any** (Claude Code / Codex / omp / Kilo / OpenCode — your choice)
 **Model: strong model, MUST differ from executor** (Opus · unic-smart · strongest available)
 
+> **omp model tiers:** the tiers above map to `.omp/config.yml`'s `modelRoles`, referenced from agent frontmatter as `@lite` / `@code` / `@smart`.
+
 ## Target (optional)
 $ARGUMENTS
 _Empty = all `pending_review` tasks. Or: "TASK-001" for a specific task._
@@ -52,7 +54,7 @@ If that diff is empty → handoff-implement was not completed. Report which task
 
 **Batch the review set — mandatory.** Read `handoff.maxParallelAgents` from `.ukit/storage/config.json`. If more `pending_review` tasks exist than that, split into consecutive batches of at most that many; finish one batch's verdicts (2a–2d, appended to each task file) before starting the next.
 
-**Claude Code — MANDATORY, do this before anything else:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"`. Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees. Pass each agent: the task file path, the executor's report, and the diff.
+**Claude Code — MANDATORY, do this before anything else:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"` (omp: the `task` tool with `agent: "code-reviewer"`, likewise invoked once per task in the batch, not once per wave). Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees. Pass each agent: the task file path, the executor's report, and the diff.
 
 The spawned reviewer agent performs 2a–2d below per task:
 
@@ -186,4 +188,4 @@ This is the only place this command may ask for a compaction. All state lives in
 `INDEX.md` and `RUN.md`, so a compacted or fresh session resumes with nothing lost.
 
 > Orchestrator (this session) handles Step 1, 2e, and 3 directly — those are not delegated.
-> Other tools without subagent support: manually switch to the strong model, run 2a–2d per task (one session at a time).
+> **For the human operator, on a tool with no agent support (Codex, OpenCode) — not an instruction to the model:** manually switch to the strong model, run 2a–2d per task (one session at a time).

package/templates/.claude/commands/ukit/handoff-status.md

@@ -45,5 +45,5 @@ Next action:
   no active cycle      → /ukit:handoff-create <description>
 ```
 
-> Claude Code: spawn `ukit-small-task-maintainer` (haiku) with the above prompt.
+> Claude Code: spawn `ukit-small-task-maintainer` (haiku) with the above prompt. omp: the `task` tool with `agent: "ukit-small-task-maintainer"`.
 > Other tools: use lite model, run the reads above, format the report.

package/templates/.claude/ukit/index/route-catalog.mjs

@@ -256,7 +256,7 @@ export const ROUTE_CATALOG = [
     signals: [
       { type: 'prompt', regex: /\b(stale|refresh|cleanup|reinstall|maintenance|workspace drift|index freshness|out of date)\b/i, score: 4 },
       { type: 'command', regex: /\bukit install\b|\brefresh-index\.mjs\b|\bbuild-index\.mjs\b/i, score: 3 },
-      { type: 'file', regex: /\.claude\/|\.codex\/|\.antigravity\//i, score: 1 },
+      { type: 'file', regex: /\.claude\/|\.codex\/|\.antigravity\/|\.omp\//i, score: 1 },
     ],
   },
   {

package/templates/.claude/ukit/index/unic-gateway.mjs

@@ -14,13 +14,29 @@
  *   2. project .claude/settings.json -> env.ANTHROPIC_BASE_URL -> 'claude-settings'
  *   3. ~/.claude/settings.json -> env.ANTHROPIC_BASE_URL       -> 'claude-settings'
  *
- * Cross-tool configs are NOT probed. This module is only ever invoked from Claude Code hooks
- * (vision-router.sh, vision-gate.sh, route-task.mjs) to gate what THIS session does — a Codex
- * `config.toml` `base_url`, a Kilo `secrets.json` endpoint, or an `OPENAI_BASE_URL` env var
- * describe a completely different tool's outbound endpoint and say nothing about where Claude
- * Code itself is sending requests. Treating them as evidence produced permanent false positives
- * (any machine with Codex/Kilo pointed at the UNIC gateway would report `unicMode: true` for
- * every plain Claude Code session, deadlocking Edit/Write on any image-mentioning turn).
+ * omp needs no probe of its own: verified against omp v17.4.2, it reads `ANTHROPIC_BASE_URL`
+ * for the anthropic provider, so probe 1 covers an omp session for the same reason it covers a
+ * Claude Code one. See the note above the probe list below for the two guessed omp probes this
+ * replaced, and why they could never have fired.
+ *
+ * Every probe here is scoped to what changes the CALLING
+ * runtime's OWN outbound endpoint — same rule that already governs probes 1-3. Cross-tool
+ * configs are NOT probed. This module is only ever invoked from Claude Code / omp hooks
+ * (vision-router.sh, vision-gate.sh, route-task.mjs, and the omp bridge) to gate what THIS
+ * session does — a Codex `config.toml` `base_url`, a Kilo `secrets.json` endpoint, or an
+ * `OPENAI_BASE_URL` env var describe a completely different tool's outbound endpoint and say
+ * nothing about where Claude Code or omp itself is sending requests. Treating them as evidence
+ * produced permanent false positives (any machine with Codex/Kilo pointed at the UNIC gateway
+ * would report `unicMode: true` for every plain Claude Code session, deadlocking Edit/Write on
+ * any image-mentioning turn).
+ *
+ * Fail-safe direction (do not re-flip this): `unicMode` keeps BINARY semantics on every runtime
+ * — `unicMode = sources.length > 0`, default `false`. Inconclusive detection never resolves to
+ * `true`. The "assume UNIC when ambiguous" fail-safe some tools want belongs ONLY to the static
+ * `modelRoles` values TASK-003 writes unconditionally into `templates/.omp/config.yml`
+ * (`@vision: unic-vision`, no probe involved) — never to this module's boolean, because this
+ * module is shared by every runtime and flipping its default would make Codex/Kilo/OPENAI_BASE_URL
+ * sessions with zero omp/Claude signal start false-positively reporting UNIC mode.
  *
  * Contract: this module must NEVER throw and must NEVER exit non-zero, in any case (missing files,
  * malformed JSON, unreadable paths, etc. all degrade to a clean "no hit").
@@ -38,6 +54,24 @@ import { fileURLToPath } from 'node:url';
 const UNIC_TOKEN = 'unicjsc.com';
 const VISION_MODEL_ALIAS = 'unic-vision';
 
+// RESOLVED 2026-08-22 against a real omp v17.4.2 install -- both omp-specific probes that
+// shipped in 2.2.1 were guesses, and both were wrong:
+//
+//   * `OMP_BASE_URL` does not exist in omp. Its bundled provider resolver reads
+//     `ANTHROPIC_BASE_URL` for the anthropic provider, falling back to
+//     "https://api.anthropic.com" -- i.e. the exact variable probe 1 already reads.
+//   * `.omp/config.yml` has no `baseUrl` key at any level. `omp config get baseUrl` answers
+//     "Unknown setting", and omp's settings schema declares none.
+//
+// So omp needs no probe of its own: an omp session pointed at the UNIC gateway is detected by
+// probe 1, on the same variable and for the same reason as a Claude Code session. That is what
+// makes the rule stated in CLAUDE.md/AGENTS.md ("routing is decided ONLY by ANTHROPIC_BASE_URL")
+// literally true on omp rather than an approximation of it. Both dead probes are removed rather
+// than left in place returning a permanent false -- a probe that can never fire is worse than no
+// probe, because it reads as coverage. Custom per-model `baseUrl` values do exist in omp, but
+// they live in its models config, not in `.omp/config.yml`; if that ever needs probing it is a
+// new probe against a verified path, not a revival of these.
+
 function safeReadFile(filePath) {
   try {
     return fs.readFileSync(filePath, 'utf8');
@@ -84,6 +118,8 @@ function probeClaudeSettings(filePath) {
   return typeof value === 'string' && value.includes(UNIC_TOKEN);
 }
 
+// Narrow anchored regex probe (no YAML parsing) for the omp config file's `baseUrl` key. A
+// missing file, unreadable path, or malformed YAML all degrade to "no hit" -- never throws.
 /**
  * Checks whether the Codex model catalog exists and, if so, whether it lists `unic-vision`.
  * A missing/unreadable/malformed catalog is never an error — it degrades to "unknown" and the

package/templates/.codex/README.md

@@ -8,7 +8,7 @@ Auto-generated by UKit for OpenAI Codex.
 ## Core UKit Rule
 
 - Human-facing workflow should optimize for one remembered command: `ukit install`.
-- After install, normal work should feel natural inside **Claude/Codex/OpenCode** (and Antigravity when installed).
+- After install, normal work should feel natural inside **Claude/Codex/OpenCode/omp**.
 - **Quality first, then speed, then token discipline**: do not waste reads, logs, or repeated helper output.
 - **Never stop after read-only steps.** For implement/apply/fix requests, continue to actual Edit/Write and verification in the same turn.
 

package/templates/.gitignore

@@ -46,9 +46,11 @@ Thumbs.db
 .claude/ukit/permission-usage.json
 .claude/ukit/permission-audit.log
 .cache/
+# legacy: Antigravity adapter removed in v2.2.0; leftovers must stay ignored
 .antigravity/
 .claude/
 .codex/
+.omp/
 .ukit/
 opencode.json
 AGENTS.md

package/templates/.omp/AGENTS.md

@@ -0,0 +1,9 @@
+# .omp/AGENTS.md — thin import, not a copy
+
+This file exists only so omp's native `.omp/AGENTS.md` provider (priority 100) does not shadow the
+project-root `AGENTS.md` (agents-md provider, priority 10) with duplicated content. omp resolves `@`
+imports relative to this file's own directory, so the single import line below pulls in the real,
+single-source-of-truth project instructions from the repo root. Do not inline root `AGENTS.md`'s body
+here — that would make root `AGENTS.md` stop loading on omp and let the two drift silently.
+
+@../AGENTS.md

package/templates/.omp/README.md

@@ -0,0 +1,96 @@
+# omp (Oh My Pi) adapter — {{project.name}}
+
+UKit installs this workspace so that [omp](https://omp.sh) gets the same guardrails, agents and
+context that Claude Code gets — without a second copy of the logic to keep in sync.
+
+Stack: {{project.stack}} · package manager: `{{runtime.packageManager}}`
+
+## What `ukit install` puts here
+
+Eleven files, all managed by UKit. Re-running `ukit install` overwrites them and keeps a backup of
+whatever was there before, so local edits are never silently lost — they move, they do not vanish.
+
+| Path | What it is |
+|------|------------|
+| `.omp/AGENTS.md` | Thin context entry point. Imports the root `AGENTS.md` (`@../AGENTS.md`) rather than duplicating it. |
+| `.omp/RULES.md` | Sticky hard rules that must survive compaction. |
+| `.omp/config.yml` | Model roles, tool approval policy, dangerous-command patterns, memory and compact settings. |
+| `.omp/README.md` | This file. |
+| `.omp/hooks/pre/ukit-bridge.js` | Translates omp events into Claude Code hook payloads and runs the real `.claude/hooks/*.sh` scripts. |
+| `.omp/agents/bug-debugger.md` | Debugging lane. |
+| `.omp/agents/code-reviewer.md` | Independent review lane. |
+| `.omp/agents/feature-implementer.md` | Implementation lane. |
+| `.omp/agents/handoff-planner.md` | Handoff planning lane. |
+| `.omp/agents/ukit-small-task-maintainer.md` | Low-risk chores lane. |
+| `.omp/agents/ukit-vision-analyst.md` | The only lane allowed to interpret images. |
+
+## Model roles
+
+`.omp/config.yml` defines four roles. Agent frontmatter references them as `@lite` / `@code` /
+`@smart` / `@vision`, so retargeting a whole tier is a one-line edit in one file.
+
+| Role | Default model | Agents using it |
+|------|---------------|-----------------|
+| `lite` | `unic-lite` | `ukit-small-task-maintainer` |
+| `code` | `unic-code` | `feature-implementer`, `bug-debugger` |
+| `smart` | `unic-smart` | `handoff-planner`, `code-reviewer` |
+| `vision` | `unic-vision` | `ukit-vision-analyst` |
+
+These are **literal model names on the UNIC gateway, not aliases**, and they ship as the installed
+default. If this project does not run against UNIC, a maintainer swaps the three cost tiers for the
+values in `orchestration.modelTiers[*].claudeModel` in `.ukit/storage/config.json`.
+
+`vision` is the exception and stays `unic-vision` either way: it is a *capability* lane, not a cost
+tier. `unic-code` and `unic-smart` cannot read images on this gateway, so substituting one of them
+would not downgrade image analysis — it would silently produce guesses.
+
+## The six agents are shared with Claude Code
+
+The agent names here are verbatim the same as the ones under `.claude/agents/`, so the same
+instruction ("hand this to the code reviewer") routes to the same role on either runtime.
+
+What differs is only the frontmatter contract: omp reads task agents from `.omp/agents/` and
+deliberately skips `.claude/agents/*.md`, and its model field takes a `@role` reference instead of a
+model id. The prompt bodies are ported, not rewritten.
+
+## The hook bridge
+
+`.omp/hooks/pre/ukit-bridge.js` does not reimplement any guardrail. It maps an omp event to the
+matching Claude Code hook payload and executes the existing shell script under `.claude/hooks/`.
+One source of truth, two runtimes — fix a hook once and both runtimes get the fix.
+
+Two things worth knowing:
+
+**Tool names are mapped explicitly, never guessed.** omp's write surface is `edit`, `write` *and*
+`ast_edit`; all three map to the `Edit` group, or `ast_edit` would slip past `protect-files.sh` and
+`vision-gate.sh`. `eval` maps to `Bash` so it still hits `block-dangerous.sh`. Anything not in the
+table maps to nothing and runs zero scripts — it never falls back to `Bash` or `Edit`.
+
+**Failure direction is per-script, transcribed from each script's own header — not a blanket rule.**
+
+- *Fail closed* (a crash or non-zero exit blocks the action): `protect-files.sh`,
+  `stale-spec-guard.sh`, `handoff-model-guard.sh`, `vision-gate.sh`, `context-hardcap-gate.sh`,
+  `block-dangerous.sh`, `verification-guard.sh`. These are gates; a broken gate must not open.
+- *Fail open* (a crash logs a warning and the action proceeds): the advisory scripts —
+  routing, backups, output compression, context reinjection, pressure reset, handoff resume.
+  These improve a session; none of them should be able to halt one.
+
+## Why there is no `.omp/skills/` or `.omp/commands/`
+
+Their absence is deliberate, not an oversight — and if you "fix" it, a test will fail on purpose.
+
+omp discovers capabilities from several providers in priority order, and its `claude` provider
+already reads `.claude/skills/` and `.claude/commands/` directly. A copy or symlink under `.omp/`
+would register at higher (native) priority, win deduplication, and give you a second location to
+keep in sync for exactly zero new capability.
+
+`.omp/agents/` is the one case that *must* be real files, because omp explicitly does not read
+`.claude/agents/*.md`.
+
+## Installing / removing
+
+```bash
+ukit install --tools=omp          # or --tools=oh-my-pi
+ukit install                      # installs every adapter, omp included
+ukit uninstall                    # removes the paths listed above
+```

package/templates/.omp/RULES.md

@@ -0,0 +1,62 @@
+# .omp/RULES.md — sticky always-apply rules
+
+omp re-attaches this file near every turn from its native location (`.omp/RULES.md` only, never a
+copy elsewhere). It carries the always-apply subset of root `AGENTS.md` that must survive even when
+nothing else is loaded. Keep this short: every line here is a per-turn tax.
+
+## 1. Classify first, then act
+
+- **Trivial** (typo, rename, flag, obvious config) — act directly. No doc reads, no index, no agents.
+- **Simple** (1-2 files, existing pattern) — act directly, pull the smallest useful context.
+- **Non-trivial / risky** (auth, migration, shared runtime, data-loss, flaky) — index-first, then
+  activate the matching skill, then verify.
+
+Pick the lane before the first tool call. Skipping this is what turns a direct chat into a
+scattershot one.
+
+## 2. Execution Contract
+
+For implement/apply/fix requests, continue until the actual edit is made or a real blocker is found.
+Do not stop after a read-only inspection step (read/grep/glob/search).
+
+## 3. No "done" after read-only
+
+Never say "done", "applied", or "fixed" after a read-only step. Completion wording requires concrete
+edit/write evidence in the current turn, plus verification when the change is risky.
+
+## 4. Index-first loop
+
+Check `.cache/index/` freshness first. Then run
+`node .claude/ukit/index/query-index.mjs "<error|symbol|path>"` and open only the top 1-3 suspect
+files before widening further. These node scripts work unchanged under omp.
+
+## 5. Auto-activate skills
+
+Skills live in `.claude/skills/` and omp reads them through its `claude` discovery provider — no
+mirror under `.omp/`. On any non-trivial task, and again after the first tool calls reveal what the
+work really is, read the matching `SKILL.md` without being asked. Users never name skills.
+
+## 6. Delegate to bind a model tier
+
+Your own model does not change mid-turn. A tier only applies when work is handed to a task-agent in
+`.omp/agents/`, whose `model:` field (`@lite` / `@code` / `@smart` / `@vision`) resolves through
+`modelRoles` in `.omp/config.yml`.
+
+- `tiny-fix` → `@lite` · `local-fix`, `local-build`, `shared-edit`, `find-cause`, `map-impact` →
+  `@code` · `review-release` → `@smart`
+- Images: `@vision` only. `@code`/`@smart` cannot see images on the UNIC gateway and must never
+  guess at their contents — hand every image to `ukit-vision-analyst` first.
+
+Doing everything inline is exactly what makes UKit look like it only has one model. Keep direct
+execution for trivial/simple work; delegate when the tier differs or when a noisy lane would other-
+wise flood this context.
+
+## 7. Safe Patch
+
+Prefer unique current-file anchors over line numbers or stale pasted blocks. Never silently merge a
+stale spec — re-read current source and confirm before applying. Preserve existing BOM and line
+endings.
+
+> Maintainer note, not a per-turn rule: `modelRoles` in `.omp/config.yml` ships UNIC gateway names.
+> On a non-UNIC provider, edit only the three cost tiers — `lite`, `code`, `smart` — never `vision`,
+> which stays `unic-vision` because it is a capability lane, not a cost tier.