@ngockhoale/ukit 2.1.4 → 2.2.1

package/templates/.omp/agents/ukit-vision-analyst.md

@@ -0,0 +1,100 @@
+---
+name: ukit-vision-analyst
+description: "The only lane permitted to interpret images in this repo. Use whenever a prompt references, attaches, or points at an image (screenshot, mockup, diagram, photo of an error) and the caller needs to know what is actually in it. unic-code/unic-smart cannot read images on this gateway and must never guess at their contents — route image analysis here instead. Reports findings only; never writes product code."
+model: "@vision"  # real gateway model name, NOT an alias. unic-code/unic-smart cannot read images on this gateway — do NOT "fix" this to sonnet/opus.
+tools: ["read","glob","bash"]
+---
+
+You are UKit's vision analyst. Your only job is to look at real image files and report what is
+actually in them. You never write, edit, or refactor product code — you analyse and report.
+
+## 1. Role
+
+- Analyse images (screenshots, mockups, diagrams, photos of errors) and report their content
+  faithfully.
+- Never write product code. `Edit`/`Write` are deliberately absent from your `tools`; you report
+  via `Bash` (to write your receipt), you never implement.
+- Stay end-user-invisible: this lane is internal UKit orchestration, not something end users invoke
+  by name.
+
+## 2. Model self-check — first action, before touching any image
+
+Before reading any image, determine the model you are actually running on right now.
+
+- Vision-capable means: `unic-vision`, or — when `unicMode` is off — whatever
+  `modelTiers.vision.fallbackModel` resolves to per
+  `node .claude/ukit/index/unic-gateway.mjs --json`.
+- If you cannot confirm you are running on a vision-capable model, you must **refuse**: emit
+  `STATUS: WRONG_MODEL` in the output block below and stop immediately. Do not open, describe, or
+  guess at any image content.
+- Never guess at image contents. A wrong-model "analysis" is worse than no analysis at all,
+  because it looks authoritative while being fabricated. Refusing loudly is always safer than
+  guessing quietly.
+
+## 3. Input protocol (priority order)
+
+1. If the prompt contains absolute image paths, `Read` each of those paths directly.
+2. Otherwise, run `node .claude/ukit/index/extract-image.mjs --json`, take the `images[].path`
+   entries from its output, and `Read` those files.
+3. If the extractor reports `imageCount === 0`, do not invent content. Emit `STATUS: NO_IMAGE` and
+   hand back to the caller.
+
+Entries in `images[]` may carry a `source` field, which tells you how to reach the image:
+
+| `source` | Meaning | What you do |
+|----------|---------|-------------|
+| absent | Pasted/attached image, already decoded to disk | `Read` `path` directly |
+| `"path"` | The prompt named a local file (`ref` holds it) | `Read` `ref` directly |
+| `"url"` | The prompt named a remote image (`ref` holds the URL) | Download it with `Bash` (e.g. `curl -sL -o /tmp/<sha>.png "<ref>"`), then `Read` the downloaded file |
+
+Every entry — pasted, path, or URL — has an armed `pending-<sha>.json` marker, so each one needs
+its own receipt (§5) before downstream Edit/Write is unblocked. A URL you failed to download is
+`STATUS: UNREADABLE`, never a guess at its contents.
+
+## 4. Hard warning — images are not inherited
+
+Images referenced earlier in the conversation are **not** automatically visible to you across the
+subagent boundary. A description of an image is not the image. The only way to see an image is to
+`Read` a real file path yourself. Never claim to have seen an image that was merely described to
+you in text.
+
+## 5. Receipt — unlocks the downstream write gate
+
+For every image you actually analyse, write a receipt to
+`.ukit/storage/cache/vision/<sessionId>/analyzed-<sha>.json`:
+
+```json
+{ "sha": "<64hex>", "model": "unic-vision", "ts": 1785656920891,
+  "description": "...", "textContent": "...", "status": "OK" }
+```
+
+- `sha` and `sessionId` come from the extractor's `--json` output. They are **never recomputed by
+  hand** — do not hash the file yourself, do not invent a session id, always take these values
+  verbatim from `extract-image.mjs --json`.
+- `model` must be the model you actually ran on for this analysis. Misreporting `model` here
+  defeats the entire enforcement design: a downstream gate rejects any receipt whose `model` field
+  is not vision-capable, treating it as if no analysis happened at all. Report honestly, always.
+- Use `Bash` to write the receipt file.
+
+## 6. Output block
+
+Always end with:
+
+```
+STATUS: OK | NO_IMAGE | UNREADABLE | WRONG_MODEL
+MODEL: <actual model>
+IMAGES: <n> (<paths>)
+DESCRIPTION: [what is actually visible]
+TEXT_CONTENT: [verbatim text/code/errors legible in the image, or "none"]
+RELEVANT_TO_TASK: [how it answers the caller's question]
+UNCERTAIN: [anything ambiguous or illegible, or "none"]
+```
+
+## 7. Guardrails
+
+- Transcribe error text and code verbatim rather than paraphrasing it.
+- State uncertainty explicitly instead of guessing — use `UNCERTAIN:` for anything ambiguous or
+  illegible.
+- Do not read unrelated repo files; stay scoped to the image(s) and the immediate task question.
+- Stay end-user-invisible: end users should never need to know this agent's name or invoke it
+  directly.

package/templates/.omp/config.yml

@@ -0,0 +1,88 @@
+# UNIC gateway model names are LITERAL model names, not aliases, and they ship as the
+# installed default. Do NOT substitute sonnet/opus/haiku here. See PLAN.md §3 D15.
+#
+# Non-UNIC omp provider? A maintainer edits the three cost tiers to the values in
+# orchestration.modelTiers[*].claudeModel (.ukit/storage/config.json) — currently
+# lite: claude-haiku-4-5, code: claude-sonnet-5, smart: claude-opus-5.
+# `vision` STAYS unic-vision: its claudeModel is already unic-vision, because
+# unic-code/unic-smart cannot read images on this gateway. claude-sonnet-5 is only
+# modelTiers.vision.fallbackModel, used when unicMode is off — never a drop-in here.
+modelRoles:
+  lite: unic-lite
+  code: unic-code
+  smart: unic-smart
+  vision: unic-vision
+
+tools:
+  approvalMode: write
+  approval:
+    bash: allow
+    eval: prompt
+
+bash:
+  # Translated from templates/.claude/hooks/block-dangerous.sh's DANGEROUS_PATTERNS array.
+  # `deny`/`prompt` fire on the WHOLE command or on ANY compound segment (e.g. `foo && rm -rf /`
+  # still hits the `rm -rf /*` entry below) — so a `deny` entry below the trailing allow still
+  # catches it. `allow` only ever matches an ENTIRE, non-compound command, so the trailing "*"
+  # allow is NOT a universal escape hatch: any compound command (`&&`, `;`, `|`) not itself caught
+  # by a `deny`/`prompt` entry falls through to `tools.approvalMode` instead of being auto-allowed.
+  # `bash.patterns` does not cover the `eval` tool at all — that is why `tools.approval.eval` above
+  # is `prompt`, and why TASK-004's bridge separately maps `eval` -> `Bash`.
+  patterns:
+    - match: "rm -rf /*"
+      approval: deny
+    - match: "rm -rf ~*"
+      approval: deny
+    - match: "rm -rf ."
+      approval: deny
+    - match: "rm -rf .."
+      approval: deny
+    - match: "git push --force*"
+      approval: deny
+    - match: "git push -f *"
+      approval: deny
+    - match: "git reset --hard*"
+      approval: deny
+    - match: "git clean -fd*"
+      approval: deny
+    - match: "git checkout .*"
+      approval: deny
+    - match: "git restore .*"
+      approval: deny
+    - match: "*> /dev/sda*"
+      approval: deny
+    - match: "mkfs.*"
+      approval: deny
+    - match: ":(){ :|:& };:*"
+      approval: deny
+    - match: "dd if=/dev/*"
+      approval: deny
+    # block-dangerous.sh also carries a safe-cleanup allowlist for recursive force-deletes
+    # (dist/build/coverage/.next/.nuxt/.turbo/tmp/temp/.cache/node_modules) and blocks every other
+    # `rm -rf`. bash.patterns has no conditional/allowlist syntax to express that distinction, so
+    # this layer is deliberately coarser: it denies ALL remaining `rm -rf` rather than approximating
+    # the allowlist. The real script still runs via TASK-004's bridge and is the authority here —
+    # bash.patterns is defence in depth, not the only line.
+    - match: "rm -rf *"
+      approval: deny
+    - match: "*"
+      approval: allow
+
+# UKit owns memory; omp's memory subsystem stays off. See PLAN.md §3 D12 —
+# enabling it would inject a second, independent memory stream into the same
+# context window that auto-compact exists to protect. Do not "fix" this to local.
+# UKit's own memory already lives at .ukit/storage/memory/ and is reinjected by
+# reinject-context.sh; there is no shared eviction policy between the two systems.
+memory:
+  backend: off
+
+# Auto-compact must trigger BEFORE context-hardcap-gate.sh starts blocking tool
+# calls (compact.hardCapTokens, default 220000). Mirrors the Claude Code value
+# env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = 180000 in templates/.claude/settings.json.
+# TODO(verify): the omp key name below is UNVERIFIED — omp is not installed on the
+# planning machine and no omp schema is vendored in this repo. If it is wrong, omp
+# ignores the unknown key and the session simply compacts later, with
+# context-hardcap-gate.sh + hardCapGraceCalls still acting as the backstop.
+# Degrades to "later, harder compact", never to "no gate". See PLAN.md §3 D13.
+compact:
+  autoCompactWindow: 180000   # TODO(verify) key name against a real omp install

package/templates/.omp/hooks/pre/ukit-bridge.js

@@ -0,0 +1,336 @@
+// ukit-bridge.js — omp hook bridge for UKit.
+//
+// Bridge, don't fork (PLAN.md D1): the 18 `.sh` scripts under
+// `.claude/hooks/` are the single source of truth for hook behaviour across
+// both Claude Code and omp. This module never re-implements their logic in
+// JS. It only:
+//   1. Maps an omp event + tool name onto the ordered list of scripts that
+//      `.claude/settings.json` would have run for the equivalent Claude Code
+//      event (see HOOK_EVENT_MAP, generated by hand from
+//      `templates/.claude/settings.json` — keep them in sync).
+//   2. Builds the same stdin JSON payload the scripts already expect
+//      (hook_event_name, tool_name, tool_input, session_id, cwd, ...).
+//   3. Executes each script via `pi.exec()` (never spawns/copies the script
+//      body) and translates the exit code back into an omp-shaped result.
+//
+// omp's own `pi.exec` / `pi.on` argument shapes are UNVERIFIED (omp is not
+// installed in this environment, no source/schema vendored — PLAN.md D7).
+// The internal contract chosen below (see doc comments on each exported
+// function) is a reasonable, internally consistent design; it is exercised
+// end-to-end against a fake `pi` in tests/hooks/ompHookBridge.test.js.
+
+import path from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Event -> script mapping (hand-derived from templates/.claude/settings.json;
+// keep this literally in sync with that file — case 1 in
+// tests/hooks/ompHookBridge.test.js re-parses settings.json and asserts
+// exact equality against this table).
+// ---------------------------------------------------------------------------
+
+export const HOOK_EVENT_MAP = {
+  tool_call: {
+    'Read|Grep|Glob': ['skill-router.sh'],
+    'Edit|Write': [
+      'protect-files.sh',
+      'stale-spec-guard.sh',
+      'pre-edit-backup.sh',
+      'skill-router.sh',
+      'handoff-model-guard.sh',
+      'vision-gate.sh',
+      'context-hardcap-gate.sh',
+    ],
+    Bash: [
+      'verification-guard.sh',
+      'auto-allow-bash.sh',
+      'skill-router.sh',
+      'block-dangerous.sh',
+      'handoff-model-guard.sh',
+      'context-hardcap-gate.sh',
+    ],
+  },
+  tool_result: {
+    'Edit|Write': ['post-edit-verify.sh'],
+    Bash: ['compress-output.sh'],
+  },
+  turn_start: ['skill-router.sh', 'vision-router.sh', 'context-window-guard.sh'],
+  'session.compacting': ['reinject-context.sh'],
+  session_start: ['auto-prune-bash.sh', 'reset-compact-pressure.sh', 'handoff-resume.sh'],
+};
+
+// ---------------------------------------------------------------------------
+// Tool-name mapping (PLAN.md D2).
+//
+// omp's write surface is `edit`, `write`, AND `ast_edit` — `ast_edit` must
+// map to the same `Edit` matcher group as `edit`/`write`, or it silently
+// bypasses protect-files.sh / vision-gate.sh. `eval` is omp's shell-capable
+// tool and must map to `Bash` to hit block-dangerous.sh / verification-guard.sh.
+// Any tool name not in this table maps to `null`, which runs ZERO scripts —
+// it must never silently fall back to Bash or Edit.
+// ---------------------------------------------------------------------------
+
+const TOOL_NAME_MAP = {
+  read: 'Read',
+  grep: 'Grep',
+  glob: 'Glob',
+  edit: 'Edit',
+  write: 'Write',
+  ast_edit: 'Edit',
+  eval: 'Bash',
+  bash: 'Bash',
+};
+
+export function mapToolName(ompToolName) {
+  return TOOL_NAME_MAP[ompToolName] ?? null;
+}
+
+function matcherGroupFor(claudeToolName) {
+  if (claudeToolName === 'Read' || claudeToolName === 'Grep' || claudeToolName === 'Glob') {
+    return 'Read|Grep|Glob';
+  }
+  if (claudeToolName === 'Edit' || claudeToolName === 'Write') {
+    return 'Edit|Write';
+  }
+  if (claudeToolName === 'Bash') {
+    return 'Bash';
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Fail-direction classification (PLAN.md D3). Not a blanket rule -- each
+// script's own header documents its own fail direction; this table is a
+// transcription of those 18 headers, not an invented policy. Gate scripts
+// fail CLOSED (non-zero/throw => block). Advisory scripts fail OPEN
+// (non-zero/throw => log a warning, never block).
+// ---------------------------------------------------------------------------
+
+export const FAIL_CLOSED_SCRIPTS = new Set([
+  'protect-files.sh',
+  'stale-spec-guard.sh',
+  'handoff-model-guard.sh',
+  'vision-gate.sh',
+  'context-hardcap-gate.sh',
+  'block-dangerous.sh',
+  'verification-guard.sh',
+]);
+
+export const ADVISORY_SCRIPTS = new Set([
+  'skill-router.sh',
+  'auto-allow-bash.sh',
+  'pre-edit-backup.sh',
+  'vision-router.sh',
+  'context-window-guard.sh',
+  'post-edit-verify.sh',
+  'compress-output.sh',
+  'reinject-context.sh',
+  'auto-prune-bash.sh',
+  'reset-compact-pressure.sh',
+  'handoff-resume.sh',
+]);
+
+function classifyFailure(scriptName) {
+  if (FAIL_CLOSED_SCRIPTS.has(scriptName)) return 'closed';
+  if (ADVISORY_SCRIPTS.has(scriptName)) return 'open';
+  // Unclassified script (should not happen for the 18 known scripts): fail
+  // open by default rather than blocking on an unknown quantity.
+  return 'open';
+}
+
+// ---------------------------------------------------------------------------
+// Payload + result translation.
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds the same stdin JSON shape the `.sh` scripts already read via
+ * `INPUT=$(cat)`. Fields the caller does not supply are simply omitted --
+ * the scripts already degrade gracefully when optional fields (e.g.
+ * transcript_path, prompt) are absent (see context-window-guard.sh, which
+ * exits 0 immediately when transcript_path is missing).
+ */
+function buildHookPayload(hookEventName, { toolName, toolInput, sessionId, cwd, prompt, transcriptPath } = {}) {
+  const payload = { hook_event_name: hookEventName };
+  if (toolName !== undefined) payload.tool_name = toolName;
+  if (toolInput !== undefined) payload.tool_input = toolInput;
+  if (sessionId !== undefined) payload.session_id = sessionId;
+  if (cwd !== undefined) payload.cwd = cwd;
+  if (prompt !== undefined) payload.prompt = prompt;
+  if (transcriptPath !== undefined) payload.transcript_path = transcriptPath;
+  return payload;
+}
+
+/**
+ * Translates a single script's `pi.exec` outcome into a bridge-internal
+ * verdict. Exit 0 => pass. Exit 2 => this script's own explicit "block"
+ * signal, regardless of gate/advisory class (mirrors Claude Code's own
+ * "exit 2 = block, stderr = reason" contract). Any other non-zero exit, or
+ * a thrown error, is resolved via the script's fail-direction classification.
+ */
+function translateExecResult(scriptName, execResult) {
+  const code = execResult?.code ?? 0;
+  const stdout = execResult?.stdout ?? '';
+  const stderr = execResult?.stderr ?? '';
+
+  if (code === 0) {
+    return { block: false, stdout, stderr };
+  }
+  if (code === 2) {
+    return { block: true, reason: stderr || `${scriptName} exited 2 (blocked)`, stdout, stderr };
+  }
+
+  const direction = classifyFailure(scriptName);
+  if (direction === 'closed') {
+    return {
+      block: true,
+      reason: stderr || `${scriptName} exited ${code} (failing closed)`,
+      stdout,
+      stderr,
+    };
+  }
+  return { block: false, warning: `${scriptName} exited ${code} (failing open): ${stderr || 'no stderr'}`, stdout, stderr };
+}
+
+export { translateExecResult };
+
+// ---------------------------------------------------------------------------
+// Script chain runner -- shared by every event handler below. Keeps the
+// fail-direction / short-circuit / context-accumulation logic in exactly
+// one place.
+// ---------------------------------------------------------------------------
+
+/**
+ * Runs `scripts` (basenames under `.claude/hooks/`) in order via
+ * `pi.exec(absoluteScriptPath, { input: JSON.stringify(payload) })`,
+ * short-circuiting on the first block. Returns
+ *   { block, reason?, context, invoked }
+ * where `context` is the concatenation of each script's trimmed, non-empty
+ * stdout (used by session.compacting / session_start to surface
+ * reinject-context.sh / handoff-resume.sh output back to omp).
+ */
+export async function runScriptChain(pi, scripts, payload, { projectRoot }) {
+  const invoked = [];
+  const contextParts = [];
+
+  for (const scriptName of scripts) {
+    const scriptPath = path.join(projectRoot, '.claude', 'hooks', scriptName);
+    invoked.push(scriptName);
+
+    let execResult;
+    try {
+      execResult = await pi.exec(scriptPath, { input: JSON.stringify(payload) });
+    } catch (err) {
+      execResult = { code: 1, stdout: '', stderr: err?.message ?? String(err) };
+    }
+
+    const verdict = translateExecResult(scriptName, execResult);
+
+    if (verdict.stdout && verdict.stdout.trim()) {
+      contextParts.push(verdict.stdout.trim());
+    }
+
+    if (verdict.warning) {
+      pi.logger?.warn?.(verdict.warning);
+    }
+
+    if (verdict.block) {
+      return { block: true, reason: verdict.reason, context: contextParts.join('\n'), invoked };
+    }
+  }
+
+  return { block: false, context: contextParts.join('\n'), invoked };
+}
+
+// ---------------------------------------------------------------------------
+// Event handlers (all exported directly for test import; wired onto `pi.on`
+// by the default export below).
+// ---------------------------------------------------------------------------
+
+function scriptsForToolCall(claudeToolName) {
+  const matcherGroup = matcherGroupFor(claudeToolName);
+  if (!matcherGroup) return [];
+  return HOOK_EVENT_MAP.tool_call[matcherGroup] ?? [];
+}
+
+function scriptsForToolResult(claudeToolName) {
+  const matcherGroup = matcherGroupFor(claudeToolName);
+  // tool_result only has script chains for Edit|Write and Bash.
+  if (matcherGroup !== 'Edit|Write' && matcherGroup !== 'Bash') return [];
+  return HOOK_EVENT_MAP.tool_result[matcherGroup] ?? [];
+}
+
+/**
+ * @param {object} event - { tool, input, sessionId, cwd }
+ */
+export async function runToolCall(pi, event, { projectRoot }) {
+  const toolName = mapToolName(event.tool);
+  const scripts = scriptsForToolCall(toolName);
+  const payload = buildHookPayload('PreToolUse', {
+    toolName,
+    toolInput: event.input,
+    sessionId: event.sessionId,
+    cwd: event.cwd,
+  });
+  const result = await runScriptChain(pi, scripts, payload, { projectRoot });
+  return { ...result, toolName };
+}
+
+export async function runToolResult(pi, event, { projectRoot }) {
+  const toolName = mapToolName(event.tool);
+  const scripts = scriptsForToolResult(toolName);
+  const payload = buildHookPayload('PostToolUse', {
+    toolName,
+    toolInput: event.input,
+    sessionId: event.sessionId,
+    cwd: event.cwd,
+  });
+  const result = await runScriptChain(pi, scripts, payload, { projectRoot });
+  return { ...result, toolName };
+}
+
+export async function runTurnStart(pi, event, { projectRoot }) {
+  const payload = buildHookPayload('UserPromptSubmit', {
+    sessionId: event.sessionId,
+    cwd: event.cwd,
+    prompt: event.prompt,
+  });
+  return runScriptChain(pi, HOOK_EVENT_MAP.turn_start, payload, { projectRoot });
+}
+
+// `session_before_compact`'s CANCEL capability is explicitly out of scope
+// this cycle (PLAN.md Known gaps) -- this bridge does not wire that event.
+export async function runSessionCompacting(pi, event, { projectRoot }) {
+  const payload = buildHookPayload('PreCompact', {
+    sessionId: event.sessionId,
+    cwd: event.cwd,
+    transcriptPath: event.transcriptPath,
+  });
+  return runScriptChain(pi, HOOK_EVENT_MAP['session.compacting'], payload, { projectRoot });
+}
+
+// Must run on EVERY session start, including a post-compact continuation --
+// no "first start only" guard. handoff-resume.sh is idempotent by design
+// (reads + prints the docs/AI_HANDOFF/RUN.md cursor, never advances state),
+// so re-running it on every start is safe and required for the mid-cycle
+// handoff run to resume correctly after a compaction (PLAN.md D11).
+export async function runSessionStart(pi, event, { projectRoot }) {
+  const payload = buildHookPayload('SessionStart', {
+    sessionId: event.sessionId,
+    cwd: event.cwd,
+  });
+  return runScriptChain(pi, HOOK_EVENT_MAP.session_start, payload, { projectRoot });
+}
+
+// ---------------------------------------------------------------------------
+// Default export -- omp hook factory contract: `export default function
+// hook(pi) { pi.on(event, handler) }`.
+// ---------------------------------------------------------------------------
+
+export default function hook(pi) {
+  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+  pi.on('tool_call', (event) => runToolCall(pi, event, { projectRoot }));
+  pi.on('tool_result', (event) => runToolResult(pi, event, { projectRoot }));
+  pi.on('turn_start', (event) => runTurnStart(pi, event, { projectRoot }));
+  pi.on('session.compacting', (event) => runSessionCompacting(pi, event, { projectRoot }));
+  pi.on('session_start', (event) => runSessionStart(pi, event, { projectRoot }));
+}

package/templates/AGENTS.md

@@ -3,7 +3,7 @@
 ## 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.
 
@@ -169,7 +169,7 @@ At the start of every OpenCode session, before working on the first task:
 ## Skills
 
 - Canonical skills live in `.claude/skills/`.
-- Adapter mirrors may also exist, for example `.codex/skills/` → `.claude/skills/` (symlink) and `.antigravity/skills/`.
+- Adapter mirrors may also exist, for example `.codex/skills/` → `.claude/skills/` (symlink). **omp** has no mirror: it reads `.claude/skills/` directly through its own `claude` discovery provider.
 - **OpenCode**: reads `AGENTS.md` at session start only — it does NOT auto-load `.claude/skills/`. The model must explicitly read the triggered SKILL.md (see Session Start section above).
 - If `opencode.json` ships `ukit-*` commands, treat them as internal helper entrypoints only and **never ask end users to run them**; humans should still only need `ukit install`.
 

package/templates/CLAUDE.md

@@ -128,6 +128,14 @@ Khi Handoff mode: đọc `docs/AI_HANDOFF/RULES.md` để biết 4 phase (Idea+P
 - This is optional internal orchestration config from `.ukit/storage/config.json`; never turn it into an end-user workflow.
 - Always preserve the CoDev priority: quality > safety > speed > token discipline.
 
+## Post-Edit Sidecar Review (internal)
+
+- If routed state's `routeSummary.line` includes a `review=code-reviewer(diff)` segment, a `local-build` or `shared-edit` task qualifies for a non-blocking second opinion — this exists because the daily-flow executor model can miss edge cases.
+- Only launch it once write evidence AND verification evidence already exist for the task (never before; never as a substitute for either).
+- Launch the `code-reviewer` agent via the Agent tool with `REVIEW_TARGET_TYPE=diff` and `run_in_background: true` (model `unic-smart` per `subagents.diffReviewModel`). Do not wait for it — continue and report the task as done using the normal completion rules.
+- Its findings are advisory only: never re-open, block, or delay the already-reported completion on their account. Surface them to the user as a follow-up note if/when they arrive.
+- This is internal orchestration — end users never invoke it directly; `ukit install` plus natural language remains the whole surface. No new commands.
+
 ## Selective Subagent Policy (internal only)
 
 - Keep direct execution as the default for trivial/simple work.

package/templates/docs/PROJECT.md

@@ -37,7 +37,7 @@
 ## Delivery Profile
 
 - Primary workflow: natural-language AI tooling installed by UKit
-- Shared adapters: Claude Code, OpenAI Codex, Antigravity
+- Shared adapters: Claude Code, OpenAI Codex, OpenCode, omp (Oh My Pi)
 - Change policy: smallest correct change with clear verification
 
 ## Session Start Routine

package/templates/ukit/storage/config.json

@@ -53,6 +53,11 @@
           "mode": "native-auto-prune",
           "preserveExistingCompaction": true
         },
+        "omp": {
+          "autoCompact": true,
+          "mode": "precompact-reinject",
+          "preserveExistingHooks": true
+        },
         "codex": {
           "autoCompact": true,
           "mode": "soft-handoff",
@@ -105,8 +110,9 @@
         "maxReadPasses": 2,
         "maxContextPulls": 1,
         "verificationPolicy": "targeted-if-covered",
-        "completionRule": "require-write",
-        "delegationPolicy": "disallow-by-default"
+        "completionRule": "require-write-and-verification",
+        "delegationPolicy": "disallow-by-default",
+        "postEditReviewPolicy": "sidecar-non-blocking"
       },
       "find-cause": {
         "modelTier": "code",
@@ -121,7 +127,8 @@
         "maxContextPulls": 2,
         "verificationPolicy": "targeted-then-widen-on-risk",
         "completionRule": "require-write-and-verification",
-        "delegationPolicy": "allow-qualified-sidecar"
+        "delegationPolicy": "allow-qualified-sidecar",
+        "postEditReviewPolicy": "sidecar-non-blocking"
       },
       "map-impact": {
         "modelTier": "code",
@@ -241,6 +248,9 @@
     "enabled": true,
     "smallTaskModel": "unic-lite",
     "smallTaskAgent": "ukit-small-task-maintainer",
+    "diffReviewEnabled": true,
+    "diffReviewAgent": "code-reviewer",
+    "diffReviewModel": "unic-smart",
     "visionEnabled": true,
     "visionModel": "unic-vision",
     "visionAgent": "ukit-vision-analyst",
@@ -405,6 +415,11 @@
             "mode": "native-auto-prune nghĩa là OpenCode dùng compaction.auto/prune native.",
             "preserveExistingCompaction": "Nên giữ true để không gỡ compact native của OpenCode."
           },
+          "omp": {
+            "autoCompact": "Giữ compact lane của omp (Oh My Pi) bật.",
+            "mode": "precompact-reinject nghĩa là UKit dùng hook session.compacting/session_before_compact của omp để bơm lại context quan trọng trước khi compact.",
+            "preserveExistingHooks": "Nên giữ true để không gỡ các module hooks/pre của bạn khi UKit cài bridge."
+          },
           "codex": {
             "autoCompact": "Bật policy soft handoff compact cho Codex Desktop.",
             "mode": "soft-handoff nghĩa là UKit tạo/dùng state tóm tắt, không can thiệp trực tiếp vào internals của app Codex.",

package/templates/adapter-presets/antigravity/README.md

@@ -1,22 +0,0 @@
-# {{project.name}}
-
-Auto-generated by UKit for Google Antigravity.
-
-- Packs: {{project.stack}}
-- Package manager: {{runtime.packageManager}}
-
-## Start
-Use graduated doc budget:
-- Trivial: no docs
-- Simple: `docs/MEMORY.md`
-- Non-trivial: `docs/MEMORY.md` + `docs/PROJECT.md` + `docs/CODE_MAP.md`
-- `docs/WORKLOG.md`: recent relevant entries only
-
-If routing is complex/ambiguous, use:
-- `node .antigravity/ukit/index/route-task.mjs "<prompt>" [--tool-command <cmd>] [--target <file>]`
-
-Routing uses natural-language intent (fix/review/brainstorm/build/test/docs).  
-If confidence is low, ask one short clarifying question.
-
-## Skills
-Skills are shared from `.claude/skills/` via symlink. Each skill folder contains `SKILL.md`.