0.8.0
The release that makes Kumano a product-management layer for agentic development: every feature now runs through Anthropic's AI-Native SDLC Playbook (intent → spec → plan → build → review → ship), each stage leaving a committed artifact, with a person at every gate.
Added
- Prompt review. Kumano hands each finished Claude session to its review engine (formerly Promptly) and, when you opt in, a judge model scores the intent behind the feature 1–5, explains the score, and suggests a clearer rewrite. The verdict shows on the card. Capture is local and free; the judge is off by default, uses your own Anthropic API key (stored in the Keychain), and switches off automatically if capture is turned off. Chat sessions are captured as well as guided runs. Needs the engine installed once with
npm i -g @getpromptly/cli; Settings → Prompt Review shows the command. - Prompt review on the pull request. When Kumano opens a PR, it can review every captured session behind it and post one comment (edited in place on re-run) plus a
promptly/prompt-reviewcheck, so a teammate sees how the change was asked for without installing anything. The card shows the same score as the check ("PR 8/10"), with avoidable spend and a link to the comment; right-click a card to re-run. Posting is its own opt-in, off by default (Settings → Prompt Review → "Post reviews to pull requests"). It scores prompt quality when the judge is on, and spend only when it's off; without a key the judge never runs. - Guided implementation loop. A feature's tickets run one after another with verification gates, app-owned state that survives closing the window, and a badge on the card showing where the loop is waiting for you. Start any ticket, add extra instructions, resume after an interruption.
- Multi-file diff review, an always-visible permission mode pill (Explore / Auto, ⇧⇥ to cycle), and a Release button that runs your repository's release workflow.
- Pull requests move cards. App-wide PR polling moves a card to Done when its PR merges; every status change is recorded with who made it (you, Claude, the PR watcher, or the guided loop), and a manual move always wins.
- Planning mode in conversations proposes board items that actually land; roadmap import extracts every feature from a plan document.
- Image attachments in both chats; Fable (Claude 5) in the model picker; Cmd+F task search.
- Skills and a verifier agent. A Skills window lists what the project defines in
.claude/skills/and creates new ones from templates shaped the way the playbook describes: a trigger condition in the description, numbered rules in the body. These are real Claude Code skills, so a skill added here applies to every session in the project, including ones started from a terminal. The same window adds the verifier — a separate agent that exercises finished work in a fresh context and reports what actually happened, instructed not to change anything and given only the tools it needs to read and to run the project's own build and tests, so a change isn't judged by the thing that wrote it. Existing skills are never overwritten. (SDLC alignment, slice F.) - Every change gets a review pass before a person reads it. A guided feature that has finished its tickets offers "Review This Change": Claude reads the branch diff and the feature's accepted artifacts, and reports findings as Important or Nit. The passes, the severity bar, the nit cap and the exclusions live in
REVIEW.mdat the repo root — the project's policy, version-controlled and edited freely; Kumano writes a starting one if there is none. Findings never approve or block, and the view says so: a person still reviews the pull request. (SDLC alignment, slice E.) - Intent and spec become committed artifacts. Creating a feature now asks what problem it solves and what should be true when it's done, with affected systems, constraints and open questions behind a disclosure; that becomes
.kumano/features/<slug>-<id>/intent.md, staged and committed with the feature's first checkpoint. From an intent, "Generate Spec" has Claude read the codebase (read-only — a non-interactive run applies no edits) and draft requirements, design, impact and concerns; the concerns are listed separately so they are read before the spec is accepted, and accepting writes and stagesspec.md. An artifact edited in the repository is the accepted one: Kumano compares what's on disk against what it last wrote and leaves a hand-edited file alone. The plan run is briefed with both, and a card shows which of intent / spec / plan exist. Roadmap import fills the intent it already extracts. (SDLC alignment, slice D.) - CLAUDE.md carries the project's real commands. Kumano detects build/test/lint/run commands from the repository (Makefile targets, package.json scripts with the right package manager, Xcode scheme and destination, SwiftPM, Cargo, Go, Python, Gradle/Maven, .NET, Flutter), shows them on the last step of project creation, and writes them into a Commands section. Verification instructions in chat and the guided loop now ask for those commands instead of
<scheme>placeholders, with "fix the code, not the test" attached. Projects created before this backfill their commands the first time they are needed. (SDLC alignment, slice C.) - Plan first, keep the plan. New chat tasks start in Explore (plan mode); a guided feature is planned before any ticket runs — Claude drafts the plan in plan mode (files that change / order of work / risks / proof), the user approves, asks for changes, or skips, and the approved plan is written to
.kumano/features/<slug>-<id>/plan.md, committed on the feature branch, and briefed into every ticket. Chat plan approvals write the same file. The Kanban badge shows "Plan ready for review" while the gate is open. (SDLC alignment, slice B.) .kumano/features/is committed. The blanket.kumano/ignore rule written by earlier versions is narrowed in place to.kumano/tasks/,.kumano/conversations/and.kumano/attachments/; artifacts are the audit trail and belong in git.
Changed
- Local-first. The Firestore sync and collaboration layer are removed; projects live on your Mac and in your git repository.
- Version control uses real git terms (Commit, Push, Pull) with developer-first copy.
- CLAUDE.md is generated in the playbook's shape and kept to a page. Commands / Conventions / Architecture / Workflow / Common mistakes, empty sections omitted, the two-thirds-of-a-page "About This File" footer replaced by one line, and no
Last Updatedstamp to churn the file. Learned rules become the Common mistakes section, and capturing learnings now writes the file instead of only regenerating it in memory. Writing also removes an unmarked pre-marker Kumano block — but only when every line in it can be accounted for as boilerplate or as content the new section re-emits, so hand-written prose is never deleted. - Project hooks are honoured in embedded sessions. Both CLI launchers used to pass a blanket
disableAllHooksoverride, silently ignoring every guardrail in the project's.claude/settings.json(test-file protection, formatters, deploy gates). Hooks now run by default; a Settings → AI Integration switch ("Disable Claude Code hooks") remains for troubleshooting a broken hook. Failed hooks are shown in the chat as a system note with the hook's own output, and a PreToolUse block explains which hook refused what and why — instead of telling the user how to switch hooks off. (SDLC alignment, slice A — seeSDLC_ALIGNMENT.md.)