kookr-toolkit

Plugin kookr-toolkit from marketplace kookr in kookr-ai/kookr. Commands read from the repo's manifest — today.

Skills (72)

• accessible-findings

  Make a findings write-up understandable to a reader NEW to the topic without weakening a single claim — a PR description, results report, journal entry, status update, or any document presenting data, analysis, plots, or tables. Covers the WHOLE artifact, not just figures — every claim, number, tabl

• adversarial-swarm-analysis

  Analyze an open question by casting 3-5 deliberately conflicting expert roles, running them in parallel and blind to each other, sharpening them in a debate round, attacking their consensus with a devil's advocate, then synthesizing a verdict that preserves disagreement instead of averaging it. Use

• agent-efficiency-retrofit

  Analyze recent Claude Code and Codex CLI conversations for repeated inefficient tool calls, token waste, retry loops, avoidable errors, and recurring setup friction; rank improvements by benefit/ease, then implement the smallest durable guardrail after user approval.

• architecture-drift-signals

  Detect AI-induced architecture drift by measuring file-size distribution, layer-boundary violations, and dependency-graph corruption. Use to score structural health, spot drift hotspots, and produce a drift report.

• asking-the-operator

  Ask the human operator a multiple-choice question from inside a Kookr task with `kookr ask` (delivered to their phone over Telegram, and asked aloud by Lucy in the dashboard when it is open) and act on the answer. Use when you are blocked on a decision that is genuinely theirs to make, with 2-4 conc

• async-flow-control

  Async flow control patterns - AbortController cancellation, async iterators for large datasets, worker thread selection, Promise combinator choice, stream backpressure in async pipelines

• automation-design

  Design, simplify, and improve autonomous workflows, supervisors, scheduled jobs, and recovery loops across projects. Use when automation needs repeated human intervention, reports activity without results, or tries a new recovery approach. Record outcomes and refine this skill from evidence.

• autonomous-review-loop

  Run bounded autonomous implementation and independent-review correction cycles with durable accounting, exact-head merge safety, and periodic quality-preserving reflection.

• autonomous-watch-loop

  Run a long-lived watch/janitor task that polls a system on an interval and acts on what it finds. Use for "monitor X all day and do Y", task sweepers, queue drains that wait on external state, deploy and CI watchers, and any loop that would otherwise ping the operator every cycle with a status line.

• claude-code-hooks

  Claude Code hook system — all 25 event types, payloads, matchers, state machine, and integration patterns for agent monitoring

• claude-code-metrics-analysis

  Analyze Claude Code telemetry, stats-cache, and history data from ~/.claude to identify UX friction, performance issues, workflow inefficiencies, and improvement opportunities.

• claude-code-permissions

  Claude Code permission system — modes, allow/deny/ask rules, pattern syntax, settings precedence, and optimal configuration for minimal prompts with safety guardrails

• clear-technical-writing

  Write clear technical prose everywhere — code documentation (docstrings, comments, module/API/reference docs, config comments), design docs and READMEs, PR bodies/changelogs/summaries, AND explanations of genuinely hard ideas (novel algorithms, subtle failure modes, non-obvious tradeoffs). Plain-lan

• codex-pr-critic

  Critic phase for codex-pr-lessons playbook — analyze a PR and extract quality signals

• codex-pr-distill

  Distillation phase for codex-pr-lessons playbook — compress raw learnings into patterns and update skills

• codex-pr-plan

  Plan phase for codex-pr-lessons playbook — load state, determine next batch of PRs to analyze

• codex-pr-threshold

  Threshold verification for codex-pr-lessons playbook — determine if distillation should trigger

• communication-quality-review

  Review a scientific paper, article, or long-form technical document as an expert first reader and science-communication editor, through ONE assigned communication lens, and return prioritized, concrete, rigor-preserving feedback. Built to be fanned out across many subagents — each on a different (de

• dependency-injection-patterns

  Dependency injection best practices - constructor injection, composition root, lifetime management, testability, circular dependency prevention, framework independence

• disk-reclaim

  Free disk space safely when Kookr refuses task launches with "Data-directory disk free is critical" (HTTP 503, code data_directory_disk_critical), when a command fails with ENOSPC or "No space left on device", or when the operator asks to free disk space or the machine is low on disk. Classifies spa

• domain-driven-design

  DDD strategic and tactical patterns - bounded contexts, aggregates, value objects, domain events, ubiquitous language, context mapping, subdomain classification. Use when modeling domain logic, designing aggregates, or deciding where to invest in rich models vs simple CRUD.

• e2e-agent-testing

  Strategy for mocking Claude Code agents in E2E tests with canary validation against real behavior.

• error-handling-patterns

  Error handling best practices - cause chaining, boundary validation, structured errors, fire-and-forget safety, retry discipline

• event-driven-messaging-patterns

  Build reliable event pipelines with reconnect-safe subscriptions, idempotency, and contract fidelity.

• find-best-reviewers

  Find the best code reviewers in a GitHub repository or for specific file paths — uses GraphQL to analyze PR review history, filters bots, weights review states, surfaces domain specialists

• git-commit-discipline

  Git commit hygiene for AI agents - atomic commits, Conventional Commits, secret scanning, branch safety, history protection

• github-issue-workflow

  Standard workflow for creating GitHub issues with assignment and worktree branch creation for immediate implementation. Includes branch strategy and worktree conventions.

• github-labels

  GitHub label taxonomy for kookr-ai/kookr. Use when creating issues, PRs, or triaging work to apply correct labels.

• github-trending-repos

  Find and rank trending GitHub repositories by real activity signals (commit velocity, PR throughput, contributor growth) — filters out non-code repos and scores for contribution opportunity

• hook-driven-workflow-enforcement

  Use Claude Code hooks as deterministic workflow enforcement — block-then-instruct pattern, CLI command surfaces for hook interception, when to prefer hooks over CLAUDE.md/memory

• independent-merge-review

  Before an autonomous self-merge, spawn a fresh-context reviewer (Codex lane, Claude fallback) that posts a machine-readable exact-head PR verdict. Hard merge gate on kookr-ai/kookr; advisory evidence on repos that document review as advisory.

• logging-design-patterns

  Structured logging best practices - Pino JSON output, log levels, correlation IDs, PII redaction, sampling, async context, canonical log lines

• mbse-system-modeling

  Explore the current system and generate or update multi-level architecture documentation using an MBSE-lite approach: system context, capability map, containers, runtime sequences, state machines, subsystem decompositions, and boundary-smell analysis.

• monorepo-architecture

  TypeScript monorepo structure - module boundaries, dependency direction, god objects, abstraction discipline, configuration management, interface design. Use when creating packages, refactoring cross-package imports, or reviewing architecture.

• notebook-role-reuse

  Spawn an agent so it REUSES an existing Agent Notebook shelf (a "role" in the nb CLI's own terms) — loading that shelf's accumulated lessons at the start and writing new ones back to the same notebook before it returns. Use whenever you spawn a general-purpose (or named) subagent to do domain work o

• oss-fork-manager

  Fork lifecycle management for open-source contributions — fork creation, clone, upstream sync, feature branches, PR creation targeting upstream

• oss-pr-critic

  Analyze a PR from any repository and extract quality signals — description, reviews, scope, tests, CI, guidelines, outcome

• oss-pr-distill

  Distillation phase for oss-pr-lessons playbook — compress raw learnings into repo-specific patterns and update shared general skill

• oss-pr-plan

  Plan phase for oss-pr-lessons playbook — load state, determine next batch of PRs to analyze for any repository

• oss-pr-threshold

  Threshold verification for oss-pr-lessons playbook — determine if distillation should trigger for any repository

• parallel-subagent-experiments

  For a HARD, OPEN research or design problem — one where the right mechanism is unknown or the design is underdetermined, so a single attempt is a guess — run several subagents IN PARALLEL, each pursuing a DIFFERENT approach, each required to (1) ground its design in existing expert knowledge via web

• placement-picker

  Decide where to place a new rule, skill, hook, KB entry, agent, CLAUDE.md rule, memory, or context artifact. Use when choosing among user, project, plugin, hook, memory, and knowledge-base surfaces, especially before saving a behavioral rule or feedback memory. where to save, where does this go, pla

• playbook-authoring

  Create or revise Kookr playbooks and scheduled orchestration, including parameters, project identity, idempotency, model policy, and launch integration

• playwright-e2e-patterns

  Playwright E2E testing patterns. Use when playwright, E2E test, toBeVisible, route mock, modal, flaky test, or selector issues.

• pr-contribution-excellence

  Patterns for excellent open-source PR contributions, distilled from analyzing real PRs across repositories

• pr-review-triage

  Triage, fix, and resolve PR review comments end-to-end — fetch comments, assess relevance, implement fixes, push, and resolve GitHub threads. Used by post-push when feedback arrives.

• pre-pr-review

  Self-review checklist before creating a PR — repo checks, diff review, reviewer specialists, and gate state creation before gh pr create.

• process-lifecycle-patterns

  Process lifecycle and graceful shutdown - signal handling, connection draining, health probes, resource cleanup ordering, worker management, zero-downtime deploys

• realtime-state-sync

  Keep realtime UI state consistent with snapshot+delta sequencing, source tagging, dedup layers, and safe reconciliation.

• requirements-engineering

  Writing precise, testable, structured requirements - SHALL/SHOULD/MAY phrasing, INVEST stories, acceptance criteria, ubiquitous language, prioritization

• reviewer-distillation-judge

  Spawn an isolated judge subagent to evaluate reviewer predictions against real human reviews

• reviewer-distillation-meta

  Meta-mutation — improve the mutator or judge skills when the reviewer improvement loop stalls

• reviewer-distillation-mutate

  Spawn a mutator subagent to improve the reviewer skill based on judge feedback

• reviewer-distillation-predict

  Spawn an isolated reviewer subagent to blindly predict PR review comments

• reviewer-distillation-prepare

  Prepare isolated context files and fetch ground-truth reviews for selected PRs

• reviewer-distillation-select
• rfc-iterative-review
• rust-lang-rust-pre-push
• rust-lang-rust-tests
• safe-refactoring
• self-continuation-task
• self-reflect
• shell-subprocess-safety
• state-machine-workflow-patterns
• task-feedback-reflect
• task-snapshot-reflect
• tdd-workflow
• testing-patterns
• token-efficiency
• typescript-type-safety
• ui-mockup-variants
• websocket-dashboard

Subagents (25)

• ambition-amplifier

  Finds places in an RFC, roadmap, or deferred-feature list where scope was capped to dodge the hard part. Counterweight to design-minimalist. Invoke in rounds 1-2 of rfc-iterative-review; skip after round 3 unless the latest revision adds new "deferred" or "future work" items.

• api-surface-auditor

  Audits HTTP routes and WebSocket message types for consistency, completeness, type safety, and test coverage. Use when the API surface changes or before releases.

• architecture-drift-detector

  Detects architecture drift two ways — (1) doc-vs-code drift (stale docs, undocumented modules, broken dependency directions) and (2) structural drift (file-size distribution, layer-boundary violations, dependency-graph corruption). Produces a drift score and hotspot list. Use periodically or before

• architecture-smell-scanner

  Proactively scans codebase for architecture smells — god modules, scattered features, ambiguous ownership, feature envy, dense coupling. Evaluates the architecture itself, not just doc alignment. Use to find structural problems before they compound.

• assumption-archaeologist

  Traces assumptions inherited from referenced ADRs and accepted RFCs back to their source and checks whether the underlying reasoning is still valid. Invoke ONLY when the RFC proposes changes to behavior originally justified by an ADR's reasoning. Do NOT invoke for UI polish, documentation-only RFCs,

• boundary-critic

  Reviews RFCs and designs for responsibility segregation, cohesion, coupling, dependency direction, and abstraction boundary quality. Use for architecture proposals where ownership, module seams, or subsystem decomposition matter.

• change-verifier

  Independently verifies that a change actually meets its acceptance criteria — tests pass, scope is contained, nothing unrelated slipped in. Use after a patch, before claiming done or merging. Capitalizes acceptance/gate lessons in its Agent Notebook so it stops missing the same classes of defect.

• clear-writing-reviewer

  Reviews technical prose — PR bodies, changelogs, summaries, status updates, AND code documentation (docstrings, comments, module/API/reference docs, READMEs) — for cold-reader clarity. Flags jargon without gloss, telegraphic density, symbol-first summaries, missing intent, and comments that only res

• delivery-pragmatist

  Reviews RFCs and designs for implementation realism, sequencing, rollback safety, blast radius, and incremental migration viability. Use when a proposal must ship in safe stages rather than as a big-bang rewrite.

• dependency-graph-analyzer

  Analyzes actual TypeScript import graph for layering violations, circular dependencies, god modules (high fan-in/fan-out), and instability metrics. Use to assess structural health of the codebase.

• design-experimenter

  Empirically validates load-bearing claims in RFCs and designs by running real code — spawning processes, executing probes, measuring behavior, capturing ground-truth output. Use when a design has hypothetical capability or behavior claims that can be tested in reasonable time (minutes to hours) rath

• design-minimalist

  Reviews RFCs and designs for KISS, YAGNI, over-abstraction, and accidental complexity. Use when a proposal may be introducing too many layers, concepts, or generalized mechanisms for the problem at hand.

• failure-mode-analyst

  Extremely cautious risk-analysis subagent. Proactively challenges plans, reasoning, and implementations by identifying what could go wrong, hidden assumptions, edge cases, and failure modes. Use before decisions, designs, or implementations are finalized.

• macos-compat-reviewer

  Reviews a diff for macOS / cross-platform breakage — GNU-only coreutils flags, bash-4-only syntax, and runtime assumptions (no /proc, exec-bit loss, sun_path limits) that pass on Linux but fail on macOS. Use on shell scripts, subprocess-spawning code, hooks, and onboarding/build tooling before they

• module-interface-auditor

  Evaluates module public APIs for clarity, narrowness, and abstraction consistency — finds grab-bag exports, leaky abstractions, mixed abstraction levels, and over-wide interfaces. Use to assess whether module boundaries are clean.

• operability-reviewer

  Reviews RFCs and designs for observability, debuggability, runtime truth, readiness, recovery, and operator-facing diagnosability. Use when proposals affect daemons, workers, orchestration, recovery, monitoring, or any behavior that must be understood live.

• patch-author

  Writes a focused, minimal code change against a known reproduction and explicit acceptance criteria. Use once a bug is reproduced or a small unit of work is well specified. Capitalizes repo-specific fix conventions in its Agent Notebook so it stops repeating the same mistakes.

• product-owner

  Generic product owner for an onboarding / accessibility / "is this shippable to a real user?" assessment. Briefs a user-testing simulation, prioritizes its findings against an activation goal, and drafts well-formed GitHub issues PLUS onboarding-media recommendations — as DRAFTS for human approval,

• repo-cartographer

  Maps an unfamiliar repository fast — where things live, how to build/test/lint, and the conventions a change must follow. Use at the start of work in a repo the fleet hasn't learned yet, or to refresh a stale map. Capitalizes what it learns in its Agent Notebook so the next task in that repo starts

• repro-builder

  Turns a vague bug report into a minimal, deterministic failing reproduction or test harness. Use before attempting a fix, so the fix has an objective target. Capitalizes reproduction recipes in its Agent Notebook so recurring bug shapes get faster to reproduce.

• socratic-challenger

  Socratic design challenger. Asks probing, sometimes naive-sounding questions to expose gaps, hidden assumptions, and missed simpler alternatives in RFCs and designs. Use after drafting an RFC or design to stress-test it through dialogue before implementation.

• state-machine-verifier

  Compares documented state machines (system-models/, ADRs) against actual implementation — finds undocumented states, missing transitions, impossible-but-coded paths. Use when state logic is central to correctness.

• test-fixer

  Fixes failing unit tests in a single file. Use when you need to repair assertion drift, mock gaps, missing fields, or vitest quirks. Spawn multiple agents in parallel to fix many test files at once.

• test-quality-reviewer

  Reviews test code for quality problems — tautologies, implementation coupling, missing edge cases, flaky patterns, weak assertions. Use after tests pass to evaluate whether they actually catch regressions. Spawn on individual test files or directories.

• user-test-simulator

  Simulates a first-time user's install → configure → first-run journey using ONLY the product's user-facing docs, as a named persona, logging every friction point, missing prerequisite, undefined term, ambiguous instruction, and give-up moment — and flagging where a video / diagram / in-product cue w

Hooks (9)

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/reflect-memory-frontmatter-gate.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/placement-gate.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/placement-gate.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/block-memory-bash-writes.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/skill-load-counter.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/shared-chrome-notice.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/nb-inject.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/nb-retro.sh

• SubagentStop

  ${CLAUDE_PLUGIN_ROOT}/hooks/nb-retro.sh

Similar plugins