oh-my-opencode 4.14.1 → 4.15.0

package/packages/omo-codex/plugin/skills/frontend/references/design/aside.md

@@ -0,0 +1,209 @@
+# Design System Inspired by Aside
+
+> Category: Developer Tools & IDEs
+> AI browser agent. Bright product-app marketing, custom display type, soft squircle controls, agent-browser product framing.
+
+## Provenance
+
+This reference is derived from a live capture of `https://aside.com/` on 2026-06-30, plus a reconnaissance pass following `JCodesMore/ai-website-cloner-template` at commit `8dd9cb47dde0d49fec06ee1d69bedd04840f3c95`.
+
+Reviewer-run evidence artifacts for the source capture were written under `.omo/evidence/20260630-aside-frontend-reference/`:
+
+- `aside-live-extraction.json`
+- `aside-home.png`
+- `cloner-output-summary.md`
+- `cloner-desktop-1440.png`
+- `cloner-tablet-768.png`
+- `cloner-mobile-390.png`
+
+Those `.omo/evidence` files are local review artifacts, not shipped package assets. Downstream agents should recapture the live site when fidelity to the current Aside page matters. This file carries the stable, reviewer-visible digest from that capture.
+
+### Reviewer-Visible Capture Digest
+
+- **Source page:** `https://aside.com/`
+- **Source metadata:** title indicated a browser built to do real work; description framed it as a browser that completes complex work across sites, accounts, and history.
+- **Template source:** `JCodesMore/ai-website-cloner-template` at commit `8dd9cb47dde0d49fec06ee1d69bedd04840f3c95`; the template was used as a local reconnaissance workflow, not copied into this repo.
+- **Screenshots captured:** live page at 1440px wide; reconstructed reconnaissance screenshots at 1440px, 768px, and 390px widths.
+- **Page topology:** compact nav, centered hero, sky/cloud hero wash, large browser-product frame, explanatory intro band, capability sections, benchmark tabs, password/security sections, blue closing CTA band, dense footer.
+- **Extracted type signals:** `displayFont` for hero and section display; Geist for body/UI; Geist Mono available for technical specimens.
+- **Extracted scale signals:** H1 around 48px / 52px with slight negative tracking; body 16px / 24px; UI labels around 14px / 20px.
+- **Extracted surface signals:** white page canvas, ink text around `#090b0c`, soft gray controls around `#f5f5f5`, black-opacity dividers, pill trust badge, rounded/squircle CTA buttons, product-frame shadows.
+- **Responsive observations:** desktop preserves full nav and large browser frame; tablet narrows the product frame; mobile crops/stacks the frame while keeping the hero and CTA visible.
+
+Do not treat this file as a license to copy Aside's logo, product screenshots, copy, or proprietary assets. Use it as a token and layout reference for original AI-browser, agent-workflow, and product-app surfaces.
+
+## 1. Visual Theme & Atmosphere
+
+Aside's current site reads as a bright, high-confidence product application rather than a dark developer landing page. The canvas is mostly white with hairline black dividers, dense product UI, large custom display headlines, and pale sky-blue atmospheric bands in the hero and final CTA. It feels closer to a native app launch page than a SaaS template: crisp, controlled, and built around the promise that the browser itself can do real work.
+
+The signature move is the contrast between calm white space, a gentle cloud-like blue wash, and dense browser-product framing. The page opens with a centered hero, a small Y Combinator trust pill, and a large browser/app visual. Below that, sections use full-width bands, thin separators, and app-like capability cards instead of decorative feature-card grids. The tone is practical and confident: precise controls, product screenshots, benchmark pills, password/memory/security stories, and compact navigation.
+
+Rounded elements should feel like soft squircles, not generic `rounded-2xl` blobs. Live capture shows very large pill radii for trust badges and hero CTAs, medium squircle radii around compact action buttons, and square rhythm for structural section boundaries. Depth is created by product frames, soft shadows, white/black opacity borders, and layered screenshot surfaces, not by colorful background decoration.
+
+## 2. Color Palette & Roles
+
+### Core Canvas
+
+- **White** (`#ffffff`): primary page background. Use for the main canvas and broad content bands.
+- **Ink Black** (`lab(2.93655 -0.435196 -0.608262)`, approximate `#090b0c`): primary text. Use this instead of pure black when possible.
+- **Soft Gray Surface** (`lab(96.52 -0.0000298023 0.0000119209)`, approximate `#f5f5f5`): rounded control and panel surface.
+- **Hairline Divider** (`rgba(0,0,0,0.06)`): section borders and subtle containment.
+- **Muted Text** (`#737373` to `#a1a1a1` range): captions, footer links, secondary product explanations.
+
+### Action Surfaces
+
+- **Primary Button Surface**: light gray or ink-inverted depending on context. Use compact contrast instead of saturated brand color.
+- **Primary Button Text**: ink black on light controls; white on dark controls.
+- **Hover Surface**: slightly darker neutral fill with 150ms color/background/border transition.
+- **Focus Ring**: neutral gray ring. Keep it visible against white and soft gray.
+
+### Accent Use
+
+Aside's live capture does not rely on one dominant neon accent. Accents come from product imagery, benchmark pills, subtle icon color, and carefully placed dark controls. If a project needs a brand color, keep it secondary to the black/white/gray product-app system and apply it only to small signals.
+
+The current page does use pale cyan/sky-blue atmosphere in large image-backed bands. Treat that as an optional Aside signature for AI-browser launches: soft, airy, and product-framing, not a generic blue gradient background.
+
+## 3. Typography Rules
+
+### Font Family
+
+- **Display**: Aside custom display font exposed in capture as `displayFont`, fallback display sans.
+- **Body / UI**: Geist, fallback sans.
+- **Mono**: Geist Mono for code, benchmark labels, and technical specimens.
+
+### Hierarchy
+
+| Role | Font | Size | Weight | Line Height | Letter Spacing | Use |
+|---|---|---:|---:|---:|---:|---|
+| Hero Display | displayFont | 48px | 400 | 52px | -0.48px | Primary H1 |
+| Section Display | displayFont | 36px-48px | 400-500 | 1.08-1.15 | tight | Major section claims |
+| Card Title | displayFont or Geist | 24px-30px | 500 | 1.2 | normal/tight | Product capability cards |
+| Body | Geist | 16px | 400 | 24px | normal | General explanation |
+| UI Label | Geist | 14px | 500 | 20px | normal | Nav, buttons, menu labels |
+| Pill/Caption | Geist | 12px-14px | 500-550 | 1.3 | slight | Badges, metadata, benchmarks |
+
+### Principles
+
+- Use the display font for the claim, not for every word on the page.
+- Keep body copy plain, readable, and product-focused.
+- Favor medium weights over bold weights; the brand voice is confident but not shouty.
+- Avoid negative letter-spacing outside display text. The router's global rule against viewport-scaled font sizing still applies.
+
+## 4. Component Stylings
+
+### Navigation
+
+- Top navigation is compact and product-app-like.
+- Logo at left, grouped menu buttons/links in the center, download CTA at right.
+- Nav labels use Geist 14px/500 with short 150ms color/background transitions.
+- Dropdown triggers can be text buttons with no visible border until hover.
+- Mobile should collapse to icon/hamburger controls with the same neutral/squircle treatment.
+
+### Hero Trust Pill
+
+- Pill radius: full pill, visually continuous.
+- Border/fill: very subtle neutral contrast against white.
+- Text: 12px-14px Geist, medium weight.
+- Content: use as a trust or provenance signal, not a decorative chip pile.
+
+### Primary CTA
+
+- Shape: pill for hero CTA, medium squircle for standard nav/action buttons.
+- Height: 36px compact nav, 44px hero/mobile.
+- Padding: generous horizontal padding for hero; compact in nav.
+- Motion: 150ms background/color/border transition; pressed state can scale to 0.97.
+- Icon: use SVG icon from the app's icon library; do not use emoji.
+
+### Product Browser Frame
+
+This is the key Aside-inspired primitive.
+
+- Large product/browser mockup below or near the hero claim.
+- Use a real screenshot, generated bitmap, or carefully built UI surface. Do not substitute flat rectangles.
+- Contain with soft border, rounded/squircle corners, and restrained shadow.
+- Internal chrome should show real browser/app affordances: sidebar, tabs, compact controls, content panels.
+- The frame can overflow and crop at mobile widths, but the focal content must remain legible.
+
+### Capability Sections
+
+- Full-width horizontal bands separated by `border-b border-black/6` style dividers.
+- Section structure: one major claim, one explanatory block, one app-like visual or metric module.
+- Avoid three generic feature cards unless the product genuinely has three peer capabilities.
+- Link rows and "Learn more" controls stay quiet and text-forward.
+
+### Benchmark Pills / Tabs
+
+- Medium squircle radius around compact tabs.
+- Neutral backgrounds with dark text.
+- Hover/active states should be visible through fill, border, or text contrast.
+- Useful for agent benchmarks, model comparisons, task modes, and product states.
+
+## 5. Layout Principles
+
+### Structure
+
+- Full page uses stacked bands rather than isolated floating cards.
+- Hero centers the brand claim and then gives the product visual real space.
+- Sections often span full width with internal max-width constraints.
+- Footer is link-dense and calm, with grouped columns.
+
+### Spacing
+
+- Outer page padding: 8px mobile, 16px desktop.
+- Hero vertical rhythm: generous, but not editorially sparse; the product visual arrives quickly.
+- Section padding: 56px-96px depending on density.
+- Dense UI inside product frames can use 8px-16px rhythm.
+
+### Responsive Behavior
+
+- Desktop: full nav, large browser/product visual, multi-column footer.
+- Tablet: preserve product framing but reduce visual width and section padding.
+- Mobile: collapse nav, make hero text more compact, crop or stack the product frame deliberately.
+- Avoid horizontal overflow; if a browser mockup is wider than the viewport, scale or crop from a stable container.
+
+## 6. Depth, Motion & Interaction
+
+### Depth
+
+- Use hairline borders and product-frame shadows as the primary elevation language.
+- Prefer subtle neutral shadow over colored glows.
+- Layer product screenshots or UI panels to create depth.
+- Keep broad backgrounds flat white unless a product visual, hero, or closing CTA needs the current Aside-like pale sky-blue atmospheric wash.
+
+### Motion
+
+- Use short transitions for controls: color, background-color, border-color, opacity, transform.
+- Keep motion in the 150ms-200ms range with standard cubic-bezier easing.
+- Product demos may use scroll or time-based state changes, but document the interaction model in `DESIGN.md` before building.
+- Animate transform/opacity/filter only.
+
+### Interaction States
+
+Every primitive must define default, hover, active, focus-visible, disabled, loading, empty, and error states before implementation. Aside-like surfaces are quiet, so missing states are obvious.
+
+## 7. Do's and Don'ts
+
+### Do
+
+- Do use a bright canvas with crisp ink typography for the current Aside-inspired look.
+- Do use a custom display face or distinctive display substitute for hero and section claims.
+- Do preserve the product-browser frame as the memorable focal object.
+- Do use soft squircle or pill corners intentionally by component role.
+- Do build dense, useful product UI inside the hero visual.
+- Do use thin black-opacity dividers to make sections feel engineered.
+- Do keep CTA colors neutral and high contrast.
+- Do cite live screenshots or extracted design tokens when claiming Aside fidelity.
+
+### Don't
+
+- Don't resurrect the older dark-only Aside reference without checking the live site.
+- Don't copy Aside's logo, text, screenshots, or proprietary product assets.
+- Don't replace the product-browser focal object with flat geometric decoration.
+- Don't make the page a purple-blue gradient SaaS layout.
+- Don't use saturated sky blue as a giant primary CTA color; if using Aside's current atmosphere, keep it pale, cloud-like, and subordinate to the product frame.
+- Don't over-round every component equally; distinguish pills, squircles, and structural edges.
+- Don't hide visual QA behind tests. Aside-like work needs screenshots at mobile, tablet, and desktop widths.
+
+## Agent Prompt
+
+When building an Aside-inspired surface, first create or update `DESIGN.md` with: bright white product-app atmosphere, display/body/mono font roles, ink/neutral token ramp, squircle/pill component rules, a product-browser focal primitive, dense capability bands, and responsive crop/scale behavior for the product frame. Use original content and assets. Verify with screenshots at 375px, 768px, and 1280px or wider, and compare against the live-reference evidence before declaring visual fidelity.

package/packages/omo-codex/plugin/skills/frontend/references/design/clone-from-url.md

@@ -0,0 +1,65 @@
+# Clone From URL — Runtime Design-System Extraction
+
+Use this when the user gives a **live site or a URL** to clone: "clone aside.com", "rebuild this page", "make it look exactly like `<url>`". A live URL affords what a screenshot cannot — the browser's **runtime truth**. Extract that truth with the real browser, make it the `DESIGN.md` contract, then build reusable primitives against it. Never eyeball a screenshot into a one-off.
+
+## Outcome and stop rule
+
+A `DESIGN.md` whose every token, interaction state, and motion value was read from the running page with `getComputedStyle`, plus a component-level clone that an independent reviewer confirms is an extensible design system (live DOM, reused primitives) — not a screenshot-matched or pasted-image fake. Done is defined by `/visual-qa` reference-fidelity mode passing on fresh evidence, not by your own glance.
+
+## Phase 1 — Extract the runtime truth (never guess a value)
+
+Drive a real browser: Codex `browser:control-in-app-browser` first, otherwise the project's `agent-browser` / playwright / dev-browser tooling. Do NOT parse CSS files — minification, CORS, CSS-in-JS, and Tailwind utilities make source unreliable. `getComputedStyle` returns what the browser ACTUALLY rendered, so it is the only source of truth.
+
+Sweep the page and read, for every meaningful element and every repeated pattern:
+
+- **Tokens** — color, background, border, font family/size/weight, line-height, letter-spacing, radius, shadow, and spacing (padding/margin/gap). Cluster the repeated values into the token scale.
+- **Interaction states** — capture `default/hover/focus/active` (plus disabled/loading/empty/error where they exist) by DRIVING the state, then re-reading the computed style. A system with only the resting state is incomplete.
+- **Motion** — `transition` (property, duration, timing function, delay), `@keyframes` (walk `document.styleSheets` for `CSSKeyframesRule`), and `transform`. Motion is part of the contract, not decoration.
+- **Assets** — `<img>` and background-image URLs, inline SVG, `@font-face` files, video sources. Download the REAL assets; never substitute stock or placeholders.
+- **Responsive** — re-run the sweep at 375 / 768 / 1280 and record what actually changes per breakpoint.
+
+A compact sweep payload to inject through the browser's evaluate action (extend the recorded fields as needed):
+
+```js
+() => {
+  const out = [];
+  for (const el of document.querySelectorAll("*")) {
+    const s = getComputedStyle(el);
+    out.push({
+      tag: el.tagName,
+      color: s.color, background: s.backgroundColor, border: s.borderColor,
+      font: s.fontFamily, size: s.fontSize, weight: s.fontWeight,
+      lineHeight: s.lineHeight, letterSpacing: s.letterSpacing,
+      radius: s.borderRadius, shadow: s.boxShadow,
+      padding: s.padding, margin: s.margin, gap: s.gap,
+      transition: s.transition, animation: s.animation, transform: s.transform,
+    });
+  }
+  return out;
+}
+```
+
+## Phase 2 — Write the DESIGN.md contract
+
+Turn the extraction into `DESIGN.md` per `design-system-architecture.md`: token scales, typography, spacing, the component anatomy with every captured state, the motion rules, and the responsive deltas. Name which source each value came from. If a value is not in `DESIGN.md`, it may not appear in code.
+
+## Phase 3 — Clone-code reusable primitives (one at a time)
+
+Build primitives against the contract, not the screenshot. One component per cycle: implement, render, compare to the source region, fix, then move on. Use the downloaded assets. Never paste a raster or `background-image` where a live element belongs. Never approximate a token you already extracted.
+
+## Phase 4 — Reference-fidelity QA (mandatory, motion included)
+
+Verify through `/visual-qa` in reference-fidelity mode against the source captures, for every page and every breakpoint. Interaction states and animations are IN SCOPE: drive hover/focus/click/scroll, then compare the settled states AND the motion itself against the source. You are not done until the dual-oracle gate passes on fresh evidence.
+
+## Anti-patterns
+
+- Parsing CSS files instead of `getComputedStyle` — the rendered truth is the only source.
+- "CORS blocked" as an excuse — computed styles bypass it.
+- Resting state only — capture hover/focus/active and the rest.
+- Screenshot-matched one-off — build reusable, token-driven primitives.
+- Placeholder or stock assets — download and use the originals.
+- Desktop only — re-extract at each breakpoint.
+
+## Provenance
+
+This runtime-extraction workflow follows the MIT-licensed **[JCodesMore/ai-website-cloner-template](https://github.com/JCodesMore/ai-website-cloner-template)** clone-website approach: browser automation plus a `getComputedStyle` sweep, state/motion/asset capture, spec files, and visual QA. It is a project-original synthesis, not a copy of that template. Do not treat this file as a license to copy any target site's trademarks, brand assets, logos, or proprietary copy — extract the design *system* (tokens, layout grammar, component anatomy, interaction states, motion) and apply it to the user's own product and content.

package/packages/omo-codex/plugin/skills/programming/SKILL.md

@@ -5,7 +5,7 @@ description: "MUST USE for ANY work on .py .pyi .rs .ts .tsx .mts .cts .go files
 
 # Programming
 
-You are a senior engineer who writes Python, Rust, and TypeScript with one shared discipline. **Type-strict. Stack-first. Async-correct. Architecturally honest about file size.**
+You are a lazy senior engineer — lazy meaning efficient, never careless. **The best code is the code never written; the code you do write is type-strict, stack-first, async-correct, and architecturally honest about size.**
 
 This skill is an index. The hard per-language rules live under `references/`. Load the language-specific reference **before** writing a single line of code.
 
@@ -33,7 +33,9 @@ This skill is an index. The hard per-language rules live under `references/`. Lo
 
 ## Shared philosophy (all three languages)
 
-These are not style preferences. They are the six axioms every recipe in `references/` derives from.
+These are not style preferences. They are the seven axioms every recipe in `references/` derives from.
+
+0. **The best code is the code never written.** Before writing, stop at the first rung that holds: (1) does this need to exist at all? (YAGNI) (2) does this codebase already have it? — reuse the helper or pattern, do not re-implement. (3) does the standard library do it? (4) does a native platform feature cover it? (5) does an installed dependency solve it? (6) can it be one line? (7) only then, write the minimum that works. Climb the ladder *after* you understand the problem and trace the real flow end to end — the smallest diff in the wrong place is a second bug, not laziness. The ladder is a fast decision, not a written essay: pick the rung and move. **Bug fix = root cause, not symptom.** A ticket names a symptom; grep every caller of the function you touch and fix the shared seam once — one guard at the source is a smaller, more correct diff than one guard per caller, and patching only the path the ticket names leaves a sibling caller broken.
 
 1. **The type system is your proof system.** Make illegal states unrepresentable. The compiler / type checker is the cheapest test you will ever run. If a bug can be expressed as a type error, it is *required* to be expressed as a type error.
 
@@ -254,7 +256,7 @@ After every code-writing session, answer these out loud (in your reply) before d
 3. **Variant discrimination?** Did I use `if`/`elif`/`else` (or `switch` without `assertNever`, or `match` without `assert_never`) anywhere to discriminate on a tagged type or enum? If yes, rewrite as exhaustive match.
 4. **Escape hatches?** Any `Any`, `# type: ignore`, `unwrap`, `expect` outside `main`/tests, `as` numeric cast, `!`, `@ts-ignore`, `@ts-expect-error`, `#[allow]` on a real warning? If yes, fix the type or document why with a comment.
 5. **Defensive layer?** Any null check, try/except, or `isinstance` guarding a value the type system already proves? If yes, delete.
-6. **Helpers for one-off?** Any function, class, or trait introduced for a single caller that will never get a second caller? If yes, inline.
+6. **Helpers for one-off?** Any function, class, or trait introduced for a single caller that will never get a second caller? If yes, inline — axiom 0 should have caught it pre-write; this is the backstop.
 7. **Tests?** Is the behavior I just introduced locked by a test that would fail if I revert this commit?
 8. **Parameter bloat?** Any function I wrote or modified that takes more than 3 parameters — or smuggles them through a dict/kwargs/`...args`/throwaway options object? If yes, group related params into a typed value object. See [Smell 2](references/code-smells.md#smell-2--function-with-more-than-3-parameters).
 9. **Redundant verification?** Did I perform a destructive action (delete, remove, clear) and then immediately re-query to "confirm" it worked? Did I call a setter then a getter to "verify"? If yes, delete the verification — the operation's contract IS the proof. See [Smell 3](references/code-smells.md#smell-3--redundant-verification-after-a-destructive-action).

package/packages/omo-codex/plugin/skills/remove-ai-slops/SKILL.md

@@ -52,6 +52,7 @@ The agent looks for these nine categories. The first three are stylistic, the ne
 2. **Over-defensive code** — null checks for guaranteed values, try/except around code that cannot raise, isinstance checks for statically typed params, default values for required params, backward-compat shims, redundant validation duplicated at multiple layers, **broad exception catching** (`except Exception`/`except BaseException` in Python, empty `catch {}` or `catch (e) { console.error(e) }` without narrowing in TypeScript/JavaScript).
    - KEEP: validation at system boundaries (user input, external APIs), I/O error handling, nullable DB fields. Top-level boundary catch-all (CLI `main()`, HTTP handler) with explicit logging + re-raise is acceptable.
    - REFACTOR: `except Exception` → catch the specific exception you expect. Empty `catch {}` → add `instanceof` narrowing or re-throw. `catch (e) { log(e) }` → narrow with `instanceof`, handle known cases, re-throw unknown.
+   - PROOF REQUIRED: before deleting any validation or error handling at a trust boundary, Phase 2 must include an **adversarial** regression (malformed or hostile input) that fails if the guard is removed. No adversarial test → the guard stays. Redundant defense to remove is a duplicate of a check that already runs *inside* the boundary; a guard with no proof of redundancy is load-bearing.
 
 3. **Excessive complexity** — deep nesting (>3 levels), nested ternaries, complex boolean expressions (combine 4+ predicates), long parameter lists (>5 args without a struct/dataclass/object), god functions (>50 lines doing many things), overly clever one-liners that sacrifice readability, `if/elif/else` chains for type/enum/literal discrimination (must be `match/case` + `assert_never`), `object` used as a type annotation (must be `Protocol`, `TypeVar`, or explicit union).
    - KEEP: established complexity patterns in this codebase, performance-critical hot paths that intentionally use a complex idiom. `if/else` for boolean conditions and range checks (not variant discrimination).
@@ -148,22 +149,37 @@ For each in-scope source file:
 
 If you cannot establish a green baseline (e.g., test runner is broken), STOP and report. Do not proceed with cleanup on unverified ground.
 
-### Phase 3: Cleanup plan
+### Phase 3: Cleanup plan — existence first, then smells
 
-Produce an explicit plan **before** spawning the removal agents:
+The largest, safest deletion is code that should not have existed. **Before categorizing smells, run the deletion ladder on each changed unit:**
+
+- **Delete entirely** — the behavior is not needed (YAGNI, speculative, dead on arrival).
+- **Reuse** — an existing helper or pattern in this repo already does it; replace the reimplementation with a call to it.
+- **Platform / stdlib / native / dependency** — the language stdlib, the runtime, or an already-installed dependency already does it (a hand-rolled date picker → `<input type="date">`, a custom query parser → `URLSearchParams`, a bespoke debounce → the util already imported).
+- **Simplify in place** — it must exist; make it smaller.
+
+Only code that lands on **Simplify in place** proceeds to the smell categories. This turns the pass from "find smells to trim" into "first decide whether the code should exist, then trim what survives." One function replaced by a platform call is a bigger, safer win than any in-place cleanup — and it needs no per-line smell analysis.
+
+For a diff that **fixes a bug**, grep the callers of every shared function it touches. Prefer one root-cause fix at the shared seam over repeated guards at each caller — a per-caller patch that leaves a sibling caller broken is a partial fix, not a cleanup.
+
+Then produce an explicit plan **before** spawning the removal agents:
 
 ```
 File: src/foo.py
+  Ladder: 2 units simplify-in-place; 1 unit delete (native <input> replaces custom picker)
   Categories: dead code, excessive complexity, performance
   Order: dead code → complexity → performance
   Risk: medium (touches caching layer)
 
 File: src/bar.py
+  Ladder: all simplify-in-place
   Categories: obvious comments, over-defensive
   Order: comments → defensive
   Risk: low
 ```
 
+**Intentional shortcuts:** if the plan deliberately keeps a bounded simplification (a naive scan fine under N rows, a global lock, an O(n²) path), mark it in-code with a `debt:` comment naming the ceiling and the upgrade trigger (in omo, prefix with `// @allow` so the comment-checker treats it as intentional), and list it under "Remaining Risks / Deferred" in the report. That section is the debt ledger — a simplification with a known ceiling and no marker is indistinguishable from a bug.
+
 Order rule (safest → riskiest): comments → dead code → defensive → duplication → complexity → abstraction/boundary → performance → tests → oversized-modules. This minimizes blast radius of any one change.
 
 ### Phase 4: Parallel slop removal via `deep` agents in batches of 5
@@ -192,13 +208,9 @@ task(
   prompt="""
 Remove AI slops from: {file_path}
 
-In addition to your default categories (obvious comments, over-defensive code, spaghetti nesting), also evaluate these categories:
-- Excessive complexity: god functions, long parameter lists, complex booleans, nested ternaries
-- Needless abstraction: pass-through wrappers, single-use helpers, speculative indirection
-- Boundary violations: wrong-layer imports, leaky responsibilities, hidden coupling
-- Dead code: unused imports, unreachable branches, stale flags, debug leftovers
-- Duplication: copy-paste branches, redundant helpers
-- Performance equivalences: O(n²)→O(n) via set lookup, hoist computation out of loops, eager→lazy collections, batch redundant calls, cache repeated len()/length
+First run the deletion ladder from Phase 3 on this file (delete entirely / reuse existing repo code / platform-stdlib-native / simplify in place); only code that must exist proceeds to smell removal.
+
+Then evaluate EVERY category defined in this skill's "Categories (what counts as slop)" section, applying that section's KEEP and REFACTOR rules verbatim — the Categories section you have loaded is canonical, do not work from a restated subset.
 
 Apply changes in this order (safest → riskiest): comments → dead code → defensive → duplication → complexity → abstraction/boundary → performance → oversized-modules.
 
@@ -273,18 +285,19 @@ Behavior Lock:
   - Baseline status: GREEN
 
 Cleanup Plan:
-  - path/to/file1.ts: [dead code → complexity → performance]
-  - path/to/file2.py: [comments → defensive]
+  - path/to/file1.ts: [ladder: 1 delete (native) + simplify-in-place] → [dead code → complexity → performance]
+  - path/to/file2.py: [ladder: all simplify-in-place] → [comments → defensive]
 
-Per-File Results:
+Per-File Results (each cut shows what replaces it):
   path/to/file1.ts
-    - Dead code: 3 removed (lines X-Y, A-B, C)
+    - Ladder/delete: custom DatePicker (48 lines) → <input type="date"> (native), flatpickr import removed
+    - Dead code: 3 removed (lines X-Y, A-B, C) → nothing (unreachable)
     - Excessive complexity: 1 simplified (nested ternary at L42 → if/else)
     - Performance: 1 (line N: list scan → set lookup, O(n²)→O(n), behavior identical)
     - Skipped (preserved): 2 (defensive null check at boundary; commented WHY at L88)
 
   path/to/file2.py
-    - Obvious comments: 5 removed
+    - Obvious comments: 5 removed → nothing
     - Over-defensive: 1 simplified (redundant isinstance on typed param)
 
 Quality Gates:
@@ -302,8 +315,14 @@ Critical Review:
 Issues Found & Fixed:
   - [None] OR [Issue description → Fix applied]
 
-Remaining Risks / Deferred:
+Net Impact:
+  - LOC: -74 (removed 91, added 17)
+  - Dependencies: -1 (flatpickr removed; native <input type="date"> used)
+  - Files deleted: 1 (src/date-picker-wrapper.ts — platform-native replacement)
+
+Remaining Risks / Deferred (this section is the debt ledger):
   - [None] OR [e.g., "boundary violation in module X flagged but not refactored — needs human judgment"]
+  - `debt:` markers kept this pass: [None] OR [file:line — ceiling → upgrade trigger]
 
 Final Status: CLEAN | ISSUES FIXED | REQUIRES ATTENTION
 ```

package/packages/omo-codex/plugin/skills/visual-qa/SKILL.md

@@ -111,6 +111,16 @@ Key fields: `maxWidth`, `overflowLines[]`, `borderMisaligned`, `wideCharColumns[
 
 This JSON (diff ratio, similarity score, hotspots or overflow lines, border alignment, wide-char columns, alpha) is REFERENCE evidence to aim the reviewers. It is not the verdict by itself.
 
+### Motion and interaction capture
+
+Static screenshots miss what moves. For every interactive element and every animated region, do NOT settle for a single resting frame — capture the motion as evidence:
+
+- **Interaction states:** drive the real browser to each state before capturing. Hover the element, focus it, click/press it, and for scroll-driven surfaces scroll to trigger the effect. Capture three frames per transition: **rest** (before), **mid-transition** (~100ms in, to prove the animation exists and is smooth), and **settled** (after it completes).
+- **Entrance and scroll motion:** capture scroll-triggered reveals and any load animation as a short frame sequence (start, mid, end), not one frame. A reveal that never fires, janks, or lands in the wrong place is a defect only the sequence exposes.
+- **Reference clones:** when the reference site has its own motion, capture the reference's motion the same way and compare it to the actual — timing, easing feel, and end state.
+
+**Animation is never an excuse to skip or pass a region.** A high `diffRatio` caused by an in-flight animation is **never a valid excuse** to dismiss a defect or wave a region through. Compare **settled state to settled state** for pixel fidelity, and separately verify the motion against the **reference's own motion** (or, with no reference, against the stated intent). "The pixels differ because it animates" is a reason to capture the settled frame and the motion properly — not a reason to pass.
+
 ## Step 3 - Dispatch two read-only QA subagents in parallel
 
 This independent review is REQUIRED before any "done" claim. Do not self-review inside the main agent and call the UI verified - a self-graded pass is the failure mode this step exists to stop. Dispatch it yourself, every time, without waiting to be told. Give each reviewer the captures for every enumerated page from Step 2, not a sample, and tell it the page count so it can confirm none were skipped.
@@ -157,6 +167,7 @@ CHECK EACH:
 5. Responsive and resize behavior across viewport sizes (web) or terminal resize (TUI).
 6. Do the user-intended FEATURES actually work: interactions, states, navigation (web); input handling, resize, scroll (TUI)? Trace the code paths.
 7. Reference packet coverage: every reference page, state, viewport, and annotated requirement is implemented or explicitly marked out of scope by the user. Missing copy, missing overview content, swapped hierarchy, or unimplemented reference states are BLOCKING.
+8. Slop animation: flag motion that signals nothing. A hover-without-action (a hover that produces no state change or affordance), motion on a non-interactive element, or a decorative micro-animation with no informational purpose is slop and a REVISE finding. Motion must map to a real interaction, state, or affordance; the hero may carry one signature moment, nothing else earns decoration.
 
 OUTPUT:
 VERDICT: PASS | REVISE | FAIL

package/packages/omo-codex/plugin/test/aggregate-skills.test.mjs

@@ -8,6 +8,7 @@ import {
 	findSpawnAgentCallsWithoutForkContextFalse,
 	root,
 } from "./aggregate-plugin-fixture.mjs";
+import { listSkillFiles } from "./sync-skills-test-support.mjs";
 
 test("#given synced skills with Codex compatibility guidance #when spawn_agent is documented #then invalid role parameters are absent", async () => {
 	const skillsDir = join(root, "skills");
@@ -65,3 +66,25 @@ test("#given long-running orchestration prompts #when waiting on child agents #t
 
 	assert.deepEqual(missingLivenessGuidance, []);
 });
+
+test("#given packaged Codex prompt surfaces #when inspected #then removed sparkshell guidance is absent", async () => {
+	const promptRoots = [
+		join(root, "skills"),
+		join(root, "components", "rules", "bundled-rules"),
+		join(root, "components", "ultrawork", "agents"),
+		join(root, "components", "ulw-loop", "skills"),
+	];
+	const promptFilePattern = /\.(?:json|md|toml|ya?ml)$/i;
+	const removedSparkshellPattern = /\b(?:sparkshell|spark[-_\s]+shell)\b/i;
+	const matches = [];
+
+	for (const promptRoot of promptRoots) {
+		for (const relativePath of await listSkillFiles(promptRoot)) {
+			if (!promptFilePattern.test(relativePath)) continue;
+			const content = await readFile(join(promptRoot, relativePath), "utf8");
+			if (removedSparkshellPattern.test(content)) matches.push(`${promptRoot}/${relativePath}`);
+		}
+	}
+
+	assert.deepEqual(matches, []);
+});