v0.3.0

v0.3.0 — Tier Adaptation + Confidence + Checklists

Released: 2026-03 Theme: Different models need different rules. Scaffold the rules.

TL;DR

v0.3.0 makes the framework tier-aware: Haiku runs under harder rules than Opus because it has weaker reasoning. Confidence labels [high / medium / low / unsure] become mandatory on non-trivial findings. Pre-built CHECKLISTS/ do the thinking for audits. Multi-agent orchestration splits heavy missions across subagents. Every framework primitive you see in later releases has its root here.

Why

By v0.2.x, the framework worked for Opus but collapsed on Haiku. Haiku invented architecture, silently guessed on ambiguity, spiraled in debugging loops. The cause was not weak reasoning per se — it was weak reasoning with no external scaffold. v0.3.0 is the realization:

When reasoning is weak, scaffolding is strong.

Give Haiku a checklist and it executes it faithfully. Give it an open question and it confabulates. So: turn every reasoning-heavy task into checklist execution, and the framework survives tier regression.

What's new

Model tier adaptation

Rules diverge by tier:

Opus-class — full framework enabled; architecture suggestions OK; creative problem solving OK; may reason across files.

Sonnet-class — full framework enabled; verification pass recommended for security-critical work; cross-file reasoning OK but state assumptions explicitly.

Haiku-class — HARDER rules:

• No architecture decisions — output "requires Opus/Sonnet or user decision"
• No creative refactor — only follow established patterns in codebase
• Scope narrower — 1 file per agent call, not 1 module
• Checklist-driven — use explicit rule files, not reasoning
• Confidence scoring mandatory — every finding tagged high | medium | low | unsure
• Refuse uncertainty — unsure → defer to user, do not guess
• Verification pass mandatory — second pass removes false positives
• No speculation — "this might cause X" → forbidden

"When in doubt about tier, assume Haiku rules" becomes the default.

Confidence labels

Every non-trivial finding or code change gets a label:

• [high] — verified by running code, reading source, or official docs
• [medium] — strong pattern match from codebase, not yet runtime-verified
• [low] — inferred from naming/comments, not from actual behavior
• [unsure] — do not know

[unsure] items are listed separately for user decision, never silently guessed. This is the hard rule.

CHECKLISTS/

A new directory at the skill level (later mirrored into each project's .kasidit/CHECKLISTS/). Pre-built mechanical audit lists per stack and domain:

.kasidit/CHECKLISTS/
├── security-php.md
├── security-node.md
├── performance-sql.md
├── css-audit.md
...

Each file is a checkbox list:

## Injection
- [ ] SQL: any query() / raw() / DB::select() with string concatenation?
- [ ] SQL: ->where() with concatenated user input?
- [ ] Command: exec() / system() / shell_exec() with user input?
...

AI reads this, scans files mechanically, reports findings. The checklist does the thinking — no reasoning needed from the agent. This is the single biggest Haiku enabler.

PATTERNS.md

Project-specific patterns that AI copies, not reinvents. Records naming conventions, error handling shape, DB query style, controller structure, auth boilerplate. Without this, Haiku invents plausible-but-wrong patterns. With it, Haiku copies from proven examples.

Multi-agent orchestration

Heavy missions split across subagents for context isolation + parallelism:

Main (planner) → dispatch → Agent 1 (file), Agent 2 (file), Agent 3 (file)
                                        ↓
                                Verifier agent (Haiku: mandatory)
                                        ↓
Main (synthesizer) → report with confidence + priority

• 1 file per agent on Haiku
• 1 module per agent on Opus
• Main context stays lean — does not load file contents; delegates
• Each agent returns structured output, not prose

Verifier pass

For Haiku audits, a second agent reads the first's findings and marks which reproduce vs which were speculative. Cuts false-positive rate substantially.

Vague mission detection

Trigger words force narrowing before work begins:

• "check", "review", "audit", "look at"
• "ดูดี", "สวย", "เหมาะสม", "ปรับ"
• "เพี้ยน", "แปลก", "ไม่ตรง"
• "improve", "better", "fix", "optimize"
• "all", "every", "entire", "whole"

When these appear without specifics, the agent outputs a numbered option list and waits. Does not execute on verbal hint alone. Strictly enforced on Haiku.

CSS width audit protocol

Before fixing a "too narrow / too wide / too short" visual bug, grep all width constraints up the DOM chain:

grep -rn "max-width\|min-width\|width:" <css-files>
grep -rn "style=.*width" <view-files>

List all constraints affecting the element: class / ID selectors, parent containers, inline styles, media queries. Do not assume scope.

Review Mode

Triggers: "check", "review", "audit", "scan", "security check". Flow:

1. Narrow scope to specific files/modules (not "all")
2. Load or generate CHECKLISTS/ for the stack
3. Spawn subagents per file (Haiku) or module (Opus)
4. Each agent runs through checklist mechanically
5. Collect findings with confidence labels
6. Main synthesizes: HIGH / MED / LOW + Top 5 actionable
7. Verification pass (mandatory on Haiku)

What changed vs v0.2.1

• Added: tier adaptation (huge)
• Added: confidence labels
• Added: CHECKLISTS/
• Added: PATTERNS.md
• Added: multi-agent orchestration
• Added: verifier pass
• Added: vague mission detection
• Added: CSS width audit protocol
• Added: Review Mode

Breaking changes

• Haiku sessions now refuse to make architecture decisions. Missions that used to produce an answer ("should we split UserService?") now return requires Opus/Sonnet or user decision.
• Vague mission triggers now force narrowing before work. Missions that used to proceed on hint alone now wait for a numbered selection.

Migration

• Update .kasidit/ to include a CHECKLISTS/ directory — seed from the skill's shipped checklists, customize per project.
• Create .kasidit/PATTERNS.md with project-specific conventions. Without it, Haiku will invent and get it wrong.

See also

• Model Tiers
• v0.2.1 — prior release
• v0.7.4 — next recorded release