cckit

Autonomous execution under hard caps — run ONE long objective hands-off, OR drive the planned effort/flow set in parallel. On an APPROVED plan the captain DECIDES, MERGES each wave, and CONTINUES; it pings the human ONLY on a genuine blocker. THIN wrapper over the built-in /loop + the kit's orchestrate scripts; never a new engine.

Close an effort in ONE op — snapshot each sub-issue's diff BEFORE squash (work record), capture/judge/sync effort metrics, squash-merge the effort PR, close the parent + ALL native sub-issues, set the board Status=Done for each, garbage-collect the worktree/branch, run the optional knowledge-ingest hook, and finish with the kit-sync drift check.

Start an effort — thin caller of `cckit effort start <N>`. Creates the `effort/<N>-<slug>` integration branch + isolated bootstrapped worktree from the base branch, then marks the parent issue In Progress on the board. Sub-issues later branch from this effort branch or commit directly on it.

Start work on a GitHub issue — thin caller of `cckit start <N>`. Creates an isolated, bootstrapped worktree + `<kind>/<N>-<slug>` branch from the base branch and marks the issue In Progress on the board (if enabled). Worktree-first — there is no in-place mode.

Create an effort — a parent GitHub issue using the effort-model template (Goal / Scope / For agents / Verification) plus N native GitHub sub-issues linked via the sub-issues REST API, all added to the project board. The parent issue IS the plan.

Open the ONE pull request for an effort — `effort/<N>` → base branch — with a rich human-facing review body plus a `## For agents` section listing the file paths/entry points. Title `[Role] [#N] <title>`. Inherits labels + milestone from the parent issue and moves it to In Review on the board.

The everyday cckit loop: find the next unblocked issue and pick it up, or fan the whole unblocked wave out to subagents. Wraps `cckit next` (what can I work on now?), `cckit start <N>` (isolated worktree + branch), `cckit copilot` (parallel fan-out), and `cckit watch` (gate + merge PRs).

Forward planning from the current state: run `cckit plan-next` to inventory what the kit can already do (skills, verbs, rules, docs) and propose what to build next — grounded in that inventory — then hand a chosen item off into `/kit-effort-new`. The proposed plan always carries a mandatory docs + README step.

Write and edit end-user documentation in the house voice: kind but robust, ADHD-oriented and scannable, ZERO analogies, beginner-inclusive but expert-skippable. Encodes the page template (title → one-line description → self-explanatory left-to-right diagram → body → next-section buttons) and the diagram discipline (interactive, left-to-right, self-explanatory, never repetitive). Use it to keep every docs page readable by people with low software knowledge without watering down the substance.

Set up and run in-app visual UI annotation for a React project, wired to Claude via Agentation. Use AUTOMATICALLY when the user asks to set up / install visual annotation or an annotation toolbar, "annotate the UI / a component", click-to-annotate, give the agent visual UI feedback, review or triage UI annotations, or run "watch mode" for UI feedback. Targets a React app (Next.js, Vite, or React Router); installs the third-party `agentation` dev dependency + its MCP. Other agents are out of scope — this wires Claude Code only.

Contribute your additions and requests back upstream to claude-kit as a GitHub PR (or issue). Use AUTOMATICALLY whenever the user asks to contribute to claude-kit, submit a PR, open a PR upstream, propose a change to the kit, give back to the kit, share my agent / skill / profile with the kit, send or file a feature request, or request a feature. Opens a pull request (or, for a pure idea, an issue) against the kit's upstream repo. Works from a project scaffolded by /kit-init and customized with /kit-customize, but also stands alone.

Customize a kit-scaffolded project's .claude/ setup. Use AUTOMATICALLY whenever the user asks to create, add, edit, modify, rename, delete, or remove an agent in a project — and also to add a skill to an agent, attach skills, wire tools, find or search for a skill, suggest agents/skills for my project, lint my agents, validate an agent, build a custom profile, or pick a preset profile. Works on a project already scaffolded by /kit-init (a `.claude/` dir with `.claude/kit.config.json`).

Fast local dev loop for claude-kit itself (the plugin source). start: worktree + launch instructions for `claude --plugin-dir` (plugin loads live from disk, no cache, no version bump). Iterate with /reload-plugins. ship: auto-bump semver + kit-task-pr-auto + one-command update of the installed plugin.

Pre-digest long inputs (video transcripts, CI logs, big files, web pages) with the LOCAL model (mlx_lm.server) so the Claude session reads a short digest + pointer instead of the full content — token saving on every long read.

Garbage-collect the repo — prune worktrees whose PR already merged, delete merged local + remote branches, surface orphan/unpushed commits and stale stashes, and flag issues whose PR merged but stayed open. Dry-run by default; destructive steps require explicit confirmation.

Run the claude-kit two-tier onboarding interview — the wide-range GLOBAL profile (asked once in a lifetime, writes ~/.claude/kit.profile.<user>.json) and the per-PROJECT interview (one batched round, pre-filled from your profile + what's detected in this directory). Use AUTOMATICALLY when the user asks to onboard, set up the kit for the first time, "interview me", create my kit profile, configure a new project, or when /kit-init runs against a project with no kit profile yet. Pairs with /kit-add to stack modules (e.g. software) later.

Full security audit of the project's apps. A security expert scans for AI/prompt injection, auth/session weaknesses, CORS/CSP issues, and dependency CVEs; findings are filed as GitHub issues and roadmapped. Named kit-security-sweep (not security-review) so it doesn't shadow the Claude Code builtin /security-review (diff audit).

End-to-end delivery for a user request — fix the issue, then run the full kit cycle (start → PR → CI → merge → close → update kit) using the kit-task commands. One command takes an open issue from code to merged-on-base with the board kept in sync.

Close a GitHub issue after its PR merged. Sets the board Status to Done (if enabled). If the issue is a plan parent, flips the plan status to Complete once all deliverables are merged (no archive folder — completed plans stay visible).

Create a new GitHub issue — applies labels, milestone, and (if enabled) Projects v2 fields in one flow. Prefer this over raw `gh issue create` so the board stays in sync.

Same as kit-task-pr (commit, push, open PR) then immediately attempts to merge via kit-task-pr-merge. One command to land a branch end-to-end.

Squash-merge the open PR for the current branch, switch to the base branch, and pull. Auto-rebases onto the base if conflicts are detected.

Commit current changes, push the branch, open a PR with the right template, labels, milestone, and link to the parent issue (+ board if enabled).

Query GitHub issues (+ Projects v2 if enabled) and print a status table grouped by Role. Flags blocked items and items missing a board entry.

Feature/form/page build strategy for Next.js (App Router) + React + Supabase + RefineDev + shadcn projects. Self-gating — applies ONLY when RefineDev is in the stack.

Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.

Daily briefing — what's active on the board, what's blocked, what to focus on.

Install or identify Spec Kit (Spec-Driven Development) in this project and drive the SDD lifecycle — constitution → specify → clarify → plan → tasks → analyze → implement. Authors the constitution + template overrides from a Stack Interview, wiring the project's build standard as the feature-module override.

Supabase access conventions for any project on Supabase (Postgres + Auth + RLS) — the three-client model, the server-action auth/authz guard, RLS-first data access, typed queries, and error handling. Self-gating.