@rune-kit/rune 2.27.0 → 2.28.0

package/README.md

@@ -103,11 +103,15 @@ Plus **9 domain packs** (product, sales, data-science, support, growth, media, p
 
 ---
 
-## What's New (v2.27.0 — Calibrated Output)
+## What's New (v2.28.0 — Reasoner's Blind Spots)
+
+> **v2.28.0 (2026-07-22):** Completes the reasoning wave. Every addition targets one failure class: **a check that feels done because the model re-read its own work and agreed with itself.** `problem-solver` (v0.6.0) gains a **model failure-mode table** beside its human-bias table — pattern-match satisfaction, template hijack, fluent≠true, prior-as-fact, completion pressure, surface blindness — plus three tells that you are inside one right now (instant confident answer; a stated detail your draft never used; two failed attempts in the same framing). `verification` (v0.8.0) gains the **Constraint Loop** for deliverables carrying a mechanically checkable constraint on their own surface form (banned characters, exact counts, strict formats) — a class Rune had no coverage for: expand the constraint before drafting, verify with a tool, re-scan the whole artifact, ship byte-for-byte. `design` (v0.9.0) gains **render blindness** — a checklist item ticked from source is a prediction, and the imagined render is always flattering; visual items are marked 👁 and are ticked from a render or marked ASSUMED. Advisory throughout, no new skills.
+
+### Previous (v2.27.0 — Calibrated Output)
 
 > **v2.27.0 (2026-07-22):** Rune had one opinion about response shape — `caveman`, optimising token count — and no rule for what a style may **not** compress. That gap had teeth: caveman's "hedging dies" list auto-activates at ORANGE/RED context and deleted phrases like *"I'm assuming the migration ran"*, promoting an unverified claim into observed grammar at exactly the point in a session where the agent is most likely to be wrong. New **output-mode layer** (`context-engine`) holds every mode behind one activation contract and a five-rule precedence list — **shape is negotiable, substance is not**: calibration > evidence > a skill's `## Output Format` > safety > actionability > economy. New **`actionable` mode** optimises distance-to-doing (next action first, steps numbered, position restated each turn) and stacks with caveman. New **claim discipline** in `completion-gate` types every load-bearing statement OBSERVED / DERIVED / PRIOR / ASSUMED — *hallucination is an unverified claim wearing the grammar of an observation* — and adds a `DECLARED` verdict so an honest hedge is recorded as an open item, never scored as a lie.
 
-### Previous (v2.26.2 — Hook Output Contract)
+#### Earlier (v2.26.2 — Hook Output Contract)
 
 > **v2.26.2 (2026-07-22):** The other half of the Codex wiring fix — v2.26.1 made the hook matchers fire, this makes the hooks **succeed**. Codex parses hook stdout as JSON and reports anything else as `hook: <Event> Failed`, discarding the output; Rune's hooks printed bare `[Rune: ...]` lines, so every hook that loaded on Codex ran, exited 0, and had its output thrown away. Hooks now emit the envelope both runtimes accept — `hookSpecificOutput.additionalContext` for context events, `systemMessage` otherwise — which is Claude Code's documented contract too, not a Codex branch. Verified live against codex-cli 0.145: the same hook goes `SessionStart Failed` → `SessionStart Completed`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.27.0",
+  "version": "2.28.0",
   "description": "65-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 204 connections + 43 signals, multi-platform compiler. converge (L3) scans spec vs code so dead-button/frontend-only implementations can't ship.",
   "type": "module",
   "bin": {

package/skills/design/SKILL.md

@@ -3,7 +3,7 @@ name: design
 description: "Design system reasoning. Maps product domain to style, palette, typography, and platform-specific patterns. Generates .rune/design-system.md as the shared design contract for all UI-generating skills."
 metadata:
   author: runedev
-  version: "0.8.0"
+  version: "0.9.0"
   layer: L2
   model: sonnet
   group: creation
@@ -27,6 +27,7 @@ Design system reasoning layer. Converts a product description into a concrete de
 
 - `scout` (L2): detect existing design tokens, component library, platform targets
 - `asset-creator` (L3): generate base visual assets (logo, OG image) from design system
+- `browser-pilot` (L3): render the surface and inspect it before claiming any visual property holds (Step 5.4)
 - `review` (L2): accessibility violations found → flag for fix in next code review
 
 ## Called By (inbound)
@@ -477,21 +478,47 @@ sm: 6px | md: 8px | lg: 12px | xl: 16px | full: 9999px
 [detected library or "custom"]
 
 ## Pre-Delivery Checklist
-- [ ] Color contrast ≥ 4.5:1 for all text
-- [ ] Focus-visible ring on ALL interactive elements (never outline-none alone)
-- [ ] Touch targets ≥ 44×44px on mobile / ≥ 24×24px on desktop, with 8px gap between targets (matches Step 2.9 Rule 1)
+> Items marked 👁 describe what a human would SEE — tick them only from a render, or mark them ASSUMED (Step 5.4).
+- [ ] 👁 Color contrast ≥ 4.5:1 for all text
+- [ ] 👁 Focus-visible ring on ALL interactive elements (never outline-none alone)
+- [ ] 👁 Touch targets ≥ 44×44px on mobile / ≥ 24×24px on desktop, with 8px gap between targets (matches Step 2.9 Rule 1)
 - [ ] All icon-only buttons have aria-label
 - [ ] All inputs have associated <label> or aria-label
-- [ ] Empty state, error state, loading state for all async data
+- [ ] 👁 Empty state, error state, loading state for all async data
 - [ ] cursor-pointer on all clickable non-button elements
 - [ ] prefers-reduced-motion respected for all animations
 - [ ] Dark mode support (or explicit reasoning why not)
-- [ ] Responsive tested at 375px / 768px / 1024px / 1440px
+- [ ] 👁 Responsive tested at 375px / 768px / 1024px / 1440px
 - [ ] No pure #000 or #fff in semantic tokens (use oklch neutrals)
 - [ ] No lorem ipsum / placeholder copy in shipped output (use real data or labelled `[ PLACEHOLDER: ... ]` blocks)
 - [ ] If multi-language: CJK-capable font listed FIRST in stack (`"Noto Sans SC", "Inter", ...`)
 ```
 
+### Step 5.4 — Render Blindness (advisory)
+
+A checklist item ticked from source is a prediction, not an observation. You emit markup and
+imagine the result, and **the imagined render is always flattering** — overflow, wrapping,
+contrast failure, misalignment and collision are invisible in source form. Every item in the
+checklist above that describes what a human would *see* is unverified until the surface is
+rendered and inspected, or the specific property is computed.
+
+| Claim | What source-reading proves | What actually settles it |
+|-------|---------------------------|--------------------------|
+| "Contrast ≥ 4.5:1" | The token values were chosen | Compute the ratio for the rendered pair — a token used on an unexpected background fails anyway |
+| "Responsive at 375px" | Breakpoints exist | Render at 375px and look: wrapping, overflow, tap-target collision |
+| "No overflow / clean alignment" | Nothing | Render — this class of failure has no textual signature |
+| "Focus ring visible" | The CSS rule exists | Tab through it; a parent `overflow:hidden` or a later rule can eat it |
+| "Empty / error / loading states work" | The branches exist | Render each one; the happy path is the only state most designs are ever seen in |
+
+**Advisory, not a gate.** When the runtime grants a browser, `browser-pilot` is the strongest
+check available and costs one call — take it, then report what was seen. When it does not,
+say so: mark the visual items **ASSUMED (not rendered)** rather than ticking them. A checklist
+of predictions labelled as observations is worse than a short one that is honest — see
+`completion-gate` → `references/claim-discipline.md`.
+
+Highest-yield renders, when budget allows only a few: narrowest breakpoint, longest realistic
+content string, empty state, dark mode.
+
 ### Step 5.5 — UI Design Contract (UI-SPEC.md)
 
 After generating the design system, lock key visual decisions in `.rune/ui-spec.md` — a binding contract that prevents design drift during implementation.

package/skills/problem-solver/SKILL.md

@@ -3,7 +3,7 @@ name: problem-solver
 description: "Structured reasoning frameworks for complex problems. 19 analytical frameworks, 12 cognitive bias detectors, 10 decomposition methods, 10 mental models, Cynefin domain classification, ethical dimension check, and 6 communication patterns. McKinsey-grade problem solving for AI coding assistants."
 metadata:
   author: runedev
-  version: "0.5.0"
+  version: "0.6.0"
   layer: L3
   model: sonnet
   group: reasoning
@@ -77,6 +77,10 @@ NEVER skip bias detection. Every problem has biases — explicitly address them.
 This is the #1 value-add from structured reasoning. Without it, solutions are just dressed-up gut feelings.
 </HARD-GATE>
 
+Two catalogs run here, not one: the biases of the people and organisation in the problem, and the failure modes of the model doing the analysis. Skipping the second is how a rigorous-looking analysis reaches a confidently wrong conclusion.
+
+#### Human and organisational biases
+
 Scan the problem statement and context for bias indicators. Check the top 6 most dangerous biases:
 
 | Bias | Detection Question | Debiasing Strategy |
@@ -96,6 +100,32 @@ Additional biases to check when relevant:
 - **Survivorship Bias**: Are we only looking at successful cases? Who tried this approach and failed?
 - **Recency Bias**: Are we extrapolating from the last few data points instead of looking at 5-10 years of data?
 
+#### Model failure modes (the reasoner's own biases — ALSO run)
+
+The table above catalogs how *humans and organisations* misjudge. It says nothing about how
+*you* misjudge. These are the failure modes of the thing doing the analysis, and naming one
+is the first countermeasure — they are invisible from the inside precisely because each one
+feels like competence.
+
+| Failure mode | What it feels like | Countermeasure |
+|--------------|--------------------|----------------|
+| **Pattern-match satisfaction** | The first explanation that fits a familiar template feels like the diagnosis | Familiarity is retrieval, not verification. Hold a second hypothesis before investigating the first |
+| **Template hijack** | A question whose surface matches a stored template ("flaky test → add retry", "slow query → add index") fires the template's answer before this question's constraints are read | Re-derive from *this* problem's details. Familiarity raises the risk, not lowers it |
+| **Fluent ≠ true** | Confidence rises as well-formed prose flows; the argument feels stronger the longer it gets | Confidence tracks evidence, not token count. Audit each point where it rose and name what moved it |
+| **Prior-as-fact** | Training knowledge stated in the grammar of observed fact | Type the claim (`completion-gate` → `references/claim-discipline.md`). Priors decay — APIs, defaults, prices, versions |
+| **Frame adoption** | The asker's framing inherited as fact ("the cache is broken again") | Trust their goal absolutely; treat their diagnosis as testimony to verify |
+| **Completion pressure** | Producing something answer-shaped now feels better than checking one more thing | An answer-shaped non-answer is worse than "here is what I verified, here is what is still open" |
+| **Surface blindness** | Any claim about the form of your own output — which symbols it contains, how many units it has — read back as true | You see tokens, not characters; a re-read always passes. Verify unit by unit or by tool (`verification` → Constraint Loop) |
+
+**Three tells you are inside one right now**: the answer arrived instantly with high
+confidence; your draft never used one of the problem's stated details; two or three attempts
+failed inside the same framing. Any tell means stop and re-derive — never repeat a failed
+probe harder.
+
+**Output**: alongside the human-bias warnings, name any model failure mode active in THIS
+analysis and what you did about it. "None apparent" is a valid answer only if you can say
+which tell you checked.
+
 **Steel Manning** (apply when evaluating competing options):
 Before dismissing any option, construct the STRONGEST possible version of the argument for it. If you can't articulate why a smart, informed person would choose it, you haven't understood it yet. Steel Manning prevents strawman dismissals and forces genuine evaluation.
 
@@ -335,6 +365,7 @@ Structure the output report using the selected pattern.
 ### Bias Warnings
 - ⚠️ [Bias 1]: [how it might affect this analysis] → [debiasing action taken]
 - ⚠️ [Bias 2]: [how it might affect this analysis] → [debiasing action taken]
+- 🤖 [Model failure mode]: [which tell fired] → [what was re-derived or verified]
 
 ### Reasoning Chain
 1. [step with evidence or reasoning]

package/skills/verification/SKILL.md

@@ -3,7 +3,7 @@ name: verification
 description: "Universal verification runner. Runs lint, type-check, tests, and build. Use after any code change to verify nothing is broken."
 metadata:
   author: runedev
-  version: "0.7.0"
+  version: "0.8.0"
   layer: L3
   model: haiku
   group: validation
@@ -207,6 +207,47 @@ Exit 0 without a confirming output artifact or success string = UNVERIFIED.
 Report the specific line that confirmed success (e.g., "3 passed, 0 failed").
 </HARD-GATE>
 
+### Surface-Constraint Verification (the Constraint Loop)
+
+Everything above verifies *behaviour* with a tool. Some deliverables instead carry a
+constraint on their own **surface form**: a banned or required character, an exact word or
+line count, a positional pattern, a strict format, a naming scheme every entry must follow,
+a diff that must not touch a listed path. These look trivial and are the opposite — a model
+generates meaning-first and reads its own output as tokens, not characters, so the
+constraint sits exactly where its perception is weakest. The most natural wording for the
+topic is usually the likeliest violator.
+
+**Re-reading the output and judging that it complies is not verification.** A re-read always
+passes. That is the whole failure mode.
+
+Run this loop whenever a deliverable carries a mechanically checkable surface constraint:
+
+1. **Expand the constraint before producing anything.** Restate it as a test every governed
+   unit must pass, and decide *how you will count* before there is anything to count. List
+   the on-topic vocabulary most likely to violate it — starting with the subject's own name,
+   which the constraint may rule out — and pick compliant substitutes up front.
+2. **Draft away from the final answer** — a scratch file or reasoning space, never straight
+   into the deliverable.
+3. **Verify mechanically, strongest tool available.** A script, `grep`, `wc`, a formatter's
+   `--check`, a schema validator — seconds of work and the strongest possible evidence. With
+   no tool available, decompose the text into the units the constraint governs and test each
+   one explicitly (spell the word out; count with a running index). Manual decomposition is
+   the fallback for tool-poor runtimes, not a substitute where a tool exists.
+4. **Repair and re-verify the whole artifact.** A fix can introduce a new violation
+   elsewhere, so re-scan everything — one green check on the edited line says nothing about
+   its neighbours. Loop until one complete pass over the final text is clean.
+5. **Ship the verified text byte-for-byte.** Any post-verification rewording, however small,
+   invalidates the check — touch one unit and step 3 runs again.
+
+<HARD-GATE name="surface-constraint">
+"The output satisfies the constraint" is a verified claim only after step 3 has run against
+the EXACT delivered text. Asserted from a re-read, it is an assumption wearing the grammar of
+an observation — see `completion-gate` → `references/claim-discipline.md`. Report the check
+that was run, not the conclusion.
+</HARD-GATE>
+
+Report it like any other phase: `Constraint: <the rule> | Check: <command or method> | Units tested: N | Violations: 0`.
+
 ## Error Recovery
 
 - If project type cannot be detected: report "Unknown project type" and skip all checks