@cbartens/bkit 5.0.1 → 5.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. package/.bkit/README.md +3 -3
  2. package/.bkit/core/.agents/rules.md +57 -57
  3. package/.bkit/core/.bkit/README.md +2 -2
  4. package/.bkit/core/.bkit/cloud.md +7 -6
  5. package/.bkit/core/.bkit/comparison.md +32 -27
  6. package/.bkit/core/.bkit/install.md +3 -3
  7. package/.bkit/core/.bkit/providers.md +6 -3
  8. package/.bkit/core/.bkit/templates.md +7 -4
  9. package/.bkit/core/.bkit/trackers.md +1 -1
  10. package/.bkit/core/engine/checks/after/github.ts +1 -1
  11. package/.bkit/core/engine/checks/after/index.ts +2 -2
  12. package/.bkit/core/engine/checks/before/env.ts +1 -1
  13. package/.bkit/core/engine/commands/install/uninstall.ts +33 -1
  14. package/.bkit/core/engine/install/cloud-env.ts +4 -1
  15. package/.bkit/core/engine/install/modules/cloud.ts +2 -2
  16. package/.bkit/core/engine/install/modules/opencode.ts +34 -13
  17. package/.bkit/shared/.bkit/.env.example +41 -12
  18. package/.bkit/shared/.claude/bkit-cloud.md +1 -1
  19. package/.bkit/shared/.cursor/bkit-cloud.md +2 -2
  20. package/.bkit/shared/.opencode/opencode.json +3 -1
  21. package/.bkit/shared/docs/deployments.md +6 -4
  22. package/.bkit/templates/.github/workflows/bkit-ci.yml +5 -2
  23. package/.bkit/templates/.github/workflows/bkit-renovate.yml +7 -5
  24. package/.bkit/templates/scripts/secrets/bkit-secrets.mjs +125 -12
  25. package/CHANGELOG.md +20 -0
  26. package/README.md +94 -35
  27. package/dist/checks/after/github.js +1 -1
  28. package/dist/checks/after/index.js +2 -2
  29. package/dist/checks/before/env.js +1 -1
  30. package/dist/commands/install/uninstall.js +21 -1
  31. package/dist/install/cloud-env.js +4 -1
  32. package/dist/install/modules/cloud.js +2 -2
  33. package/dist/install/modules/opencode.js +34 -14
  34. package/package.json +24 -2
package/CHANGELOG.md CHANGED
@@ -6,6 +6,26 @@ Format: `## [version] — YYYY-MM-DD`
6
6
 
7
7
  ---
8
8
 
9
+ ## [5.0.2] — 2026-10-12
10
+
11
+ ### Added
12
+
13
+ - **Pluggable secrets-store adapters and a built-in Cursor store** (#529). `bkit-secrets.config.mjs` gains `type: "custom"` + `module`, which loads a repo-local adapter (validated at load, its `open()` handle validated at run) so a new platform needs no upstream engine change and `bkit-secrets.mjs` stays byte-identical across repos. A new built-in `cursor` store syncs Cursor Cloud Agents secrets over the REST API v1 (`cursor:environment_variable` per-row option): environment by name or id, write-only parity from the state file, a `protects(name)` handle guard for platform-reserved names such as `build_secret`, and a pre-checked multi-version ambiguity guard.
14
+ - **OpenCode's fetch tool is gated from the same network allowlist as its shell** (#381). `permission.webfetch` becomes a URL-keyed map (`{ "*": "ask" }`) and `injectOpencodeDerivedAllows` adds `*{domain}*: allow` per resolved base (last-match-wins), mirroring the existing curl/wget globs — so a host on the allowlist no longer prompts on `%WebFetch`. Claude gates the fetch tool and not the shell; OpenCode now gates both, and the V1 object syntax is honoured natively and by 2.0's compat layer. Cursor shares the allowlist artifact and Codex inherits it (advisory — it cannot prompt). A new cross-surface parity test requires every derived base to reach Claude's WebFetch set, OpenCode's webfetch map **and** curl/wget globs, and Cursor's allowlist.
15
+ - **bkit's own CI adopts release-PR mirror mode** (#528). A same-repo PR on `dev` / `release/*` against the default branch mirrors the push run onto the PR head (`bkit runs mirror --head=$PR_HEAD_SHA --branch=dev --max-minutes=170`) and the capstone checks out and installs that head. Every `dev` push now runs the full level (the merged-PR light arm is removed). The template scaffold and `docs/deployments.md` widen the predicate to `dev|release/*`.
16
+
17
+ ### Changed
18
+
19
+ - **README and package metadata lead with audience, proof and CI template** (#505). A context-map image, a phase-true features grid and a pipeline diagram replace the earlier marketing copy; marketing numbers are rounded down and prefixed with `>`; `package.json` npm metadata (description, keywords, repository, bugs, homepage, publishConfig) is filled in for the public registry.
20
+ - **PAT-type guidance across the secrets surfaces.** `.bkit/.env.example` and the preflight / post-install advisories now carry the decision rule — a fine-grained PAT when every target repo sits under one owner, a classic PAT when one token must span owners — plus a `launchd.env` re-sync warning after rotation (GUI and daemon apps do not inherit direnv exports). Matching wording lands in `bkit-renovate.yml`, `bkit-secrets.config.mjs` and `docs/security.md`.
21
+ - **OpenCode environment handling docs** now explain how `{env:…}` resolves in the background service and that `.bkit/.env` is merged into child environments per repo.
22
+
23
+ ### Fixed
24
+
25
+ - **A targeted `bkit uninstall --<module>` no longer leaves `.bkit/version` stale.** The uninstall deleted the module's files but kept their canonical hashes in the install-state manifest, so the very next `bkit check` — the documented CI drift gate — reported write-drift on `.bkit/version` and exited 1 until the consumer re-ran `bkit install`. A targeted uninstall now recomputes and rewrites the version pin, pruning the deleted paths, exactly as the core install and upgrade paths do. A full/core uninstall still deletes the manifest for a zero footprint.
26
+
27
+ ---
28
+
9
29
  ## [5.0.1] — 2026-10-12
10
30
 
11
31
  ### Changed
package/README.md CHANGED
@@ -1,11 +1,13 @@
1
1
  <p align="center">
2
2
  <picture>
3
3
  <source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-hero-dark.svg">
4
- <img alt="bkit — from vibe coding to production code. A senior engineering team's process, run by AI agents, signed off by you." src=".github/assets/bkit-hero-light.svg" width="100%">
4
+ <img alt="bkit — from vibe coding to production code. A senior engineering team's process, ready-made, run by AI agents and battle-tested over more than 1,000 commits." src=".github/assets/bkit-hero-light.svg" width="100%">
5
5
  </picture>
6
6
  </p>
7
7
 
8
8
  <p align="center">
9
+ <a href="https://github.com/cbartens/bkit/actions/workflows/bkit-ci.yml"><img alt="CI" src="https://github.com/cbartens/bkit/actions/workflows/bkit-ci.yml/badge.svg?branch=main"></a>
10
+ <a href="https://www.npmjs.com/package/@cbartens/bkit"><img alt="npm version" src="https://img.shields.io/npm/v/@cbartens/bkit"></a>
9
11
  <a href="#license"><img alt="License: PolyForm Noncommercial or PolyForm Small Business" src="https://img.shields.io/badge/license-PolyForm%20Noncommercial%20%2F%20Small%20Business-blue"></a>
10
12
  <img alt="Node 20+" src="https://img.shields.io/badge/node-%E2%89%A520-339933">
11
13
  <img alt="Works with Claude Code, Cursor, Codex and opencode" src="https://img.shields.io/badge/works%20with-Claude%20Code%20%C2%B7%20Cursor%20%C2%B7%20Codex%20%C2%B7%20opencode-8250df">
@@ -14,43 +16,64 @@
14
16
  <p align="center">
15
17
  <a href="#quick-start">Quick start</a> ·
16
18
  <a href="#a-ready-made-workflow-for-every-job">Workflows</a> ·
17
- <a href="#how-it-works">How it works</a> ·
19
+ <a href="#a-ci-pipeline-built-the-way-senior-teams-build-them">CI template</a> ·
20
+ <a href="#right-context-at-the-right-step">Context</a> ·
18
21
  <a href="#faq">FAQ</a> ·
19
22
  <a href=".bkit/install.md">Install guide</a>
20
23
  </p>
21
24
 
22
- AI coding agents are fast, but on their own they skip the parts that make software safe to ship: a design someone challenged, a plan someone checked, a second pair of eyes on every change, tests that actually ran. You end up checking everything yourself, or shipping and hoping.
25
+ AI coding agents are fast, but on their own they skip the parts that make software safe to ship: a design someone challenged, a plan someone checked, a second pair of eyes on every change, tests that actually ran. Vibe coding gets you a demo. Getting that demo to production takes a process.
23
26
 
24
- **bkit puts the professional process back, automatically.** You describe what you want in an issue. bkit takes it through design, planning, building, testing and shipping, with separate AI agents checking each step. It stops and waits for your sign-off before anything important happens. You don't need an engineering degree to use it; you need to be able to read a plan and make a call.
27
+ **bkit is that process, ready-made.** You describe a feature in a GitHub or Linear issue. AI agents design it, plan it, build it, review it with agents that didn't write it, fix what breaks, and ship it, with project docs and memory kept up to date along the way.
28
+
29
+ - **For solo founders and makers** who have outgrown vibe coding: you get the habits of a senior engineering team without hiring one. You need to be able to read a plan and make a call, not write the code.
30
+ - **For engineers** who want a proven agentic process instead of building their own: rules, prompts, workflows, guardrails, audits and a CI pipeline that already work together.
31
+
32
+ **Battle-tested, not a weekend prompt pack.** bkit is built with bkit. Its rules, prompts and workflows have been refined over >1,000 commits, >500 issues and >100 merged pull requests run through its own pipeline, and that history is recorded in >200 lessons and >300 decisions agents read before they start.
25
33
 
26
34
  <p align="center">
27
35
  <picture>
28
36
  <source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-features-dark.svg">
29
- <img alt="What ships with bkit, one coloured row per phase. Design: independent review, three rival designs, runs on any AI tool, your sign-off. Plan: five reviewers, scope kept tight, 35 audits, best model per job. Build: writes and verifies, hunts bugs and security holes, quality checks, parallel features. Debug: self-fixing builds, root cause first, honest CI, context fetch. Ship: nothing quietly dropped, docs and memory, skills on demand, laptop to cloud." src=".github/assets/bkit-features-light.svg" width="100%">
37
+ <img alt="What ships with bkit, one coloured row per phase. Design: three rival designs, probe code for the risky unknowns, reads your history, reviewed for failure modes. Plan: five reviewers, big work split up, learns from past bugs and postponed work, more than 30 audits. Build: writes and verifies, hunts bugs and security holes, checks the plan is still current, skills on demand. Debug: outside evidence from CI and your platforms, root cause first, hard-bug mode, knows when to stop. Ship: honest CI, nothing quietly dropped, docs and memory, never touches main. Every phase: any AI tool, best model per job, independent review, laptop to cloud." src=".github/assets/bkit-features-light.svg" width="100%">
30
38
  </picture>
31
39
  </p>
32
40
 
41
+ ## >200 files of best practice, ready to use
42
+
43
+ Everything a senior team would otherwise write down over years, in files you can read:
44
+
45
+ <!-- prettier-ignore -->
46
+ | What | How many | What it does for you |
47
+ | --- | --- | --- |
48
+ | Agents | >40 | Single-job specialists, each with its own model, thinking depth and tool list. A reviewer can read code but can't change it. |
49
+ | Workflows | 6 | The five phases plus a cloud router. Every step ends in a checklist and a mechanical check before the next one starts. |
50
+ | Agent rules | >70 | One shared rulebook every agent follows: read before editing, never defer silently, report honestly, never rewrite history. |
51
+ | Guardrails | >10 hook files | Block dangerous commands and make agents investigate before they edit, on all four AI tools. |
52
+ | Audits | >30 | Security, privacy, accessibility, performance, reliability, database, LLM usage, cost and more. Findings feed straight into a plan. |
53
+ | Project docs | 10 + index | Architecture, data schema, deployments, testing, security, monitoring, design system, tech stack, setup, and an index telling each agent what to read at each step. |
54
+ | Templates | >60 | A full CI pipeline, cloud agents, git hooks, linters, dependency updates, secrets sync, code search, and >10 ready-made connectors for your platforms. |
55
+
33
56
  ## A ready-made workflow for every job
34
57
 
35
- One command per job. Each one runs a team of specialised agents, 48 in total, so you don't have to write prompts or remember steps.
58
+ One command per job. Each one runs a team of specialised agents, so you don't have to write prompts or remember steps.
36
59
 
37
60
  <!-- prettier-ignore -->
38
61
  | Job | Command | What happens |
39
62
  | --- | --- | --- |
40
- | Work out how to build it | `/bkit-design` | Three agents propose different approaches, two more critique them, and you get one design to approve. |
41
- | Plan the work | `/bkit-plan` | A step-by-step plan, stress-tested by five reviewers before any code is written. You approve it. |
42
- | Build it | `/bkit-build` | Writes the code, checks it against the plan, hunts for bugs and security holes, runs the tests, and opens a pull request. |
43
- | Fix what broke | `/bkit-debug` | Gathers external context from your platforms (CI, error trackers, hosting, databases and more), finds the cause, fixes it, re-tests, and writes down the lesson. |
44
- | Ship it | `/bkit-ship` | Checks nothing was missed, waits for every test to pass, updates the docs, and merges once you say so. |
45
- | Health check | 35 audits | Security, privacy, accessibility, performance, reliability, cost and more. Findings feed straight into `/bkit-plan`. |
46
- | Housekeeping | utility agents | Keep docs, decisions, known issues and the roadmap current. |
63
+ | Work out how to build it | `/bkit-design` | Reads related issues and past decisions, has three agents propose different approaches and two critique them, and writes throwaway code to test any risky unknowns the reviewers flag. You get one design to approve. |
64
+ | Plan the work | `/bkit-plan` | A step-by-step plan, stress-tested by five reviewers who also see past bugs and postponed work. Too big for one build? It's split into pieces. You approve it. |
65
+ | Build it | `/bkit-build` | Checks the plan still matches the code, writes it, verifies every task, hunts for bugs and security holes, adds edge-case tests, and opens a pull request. |
66
+ | Fix what broke | `/bkit-debug` | Pulls evidence from CI and your platforms, finds the root cause, fixes it, re-tests and records the lesson. Hard runtime bugs get their own mode; if it can't fix something, it stops and writes you a clear handover. |
67
+ | Ship it | `/bkit-ship` | Checks nothing planned was quietly dropped, waits for every test lane to pass, merges into `dev`, and updates the docs. |
68
+ | Health check | >30 audits | One specialist checklist per area. Findings feed straight into `/bkit-plan`. |
69
+ | Housekeeping | 7 utility agents | Keep docs, decisions, lessons and known bugs current, and rank what to work on next. |
47
70
 
48
71
  ## How it works
49
72
 
50
73
  <p align="center">
51
74
  <picture>
52
75
  <source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-pipeline-dark.svg">
53
- <img alt="The bkit pipeline: design, plan, build and ship, with debug fixing failed tests. Several AI agents work in parallel at every step. It stops for your sign-off after design, after plan, and before going live. Runs on Claude Code, Cursor, Codex and opencode." src=".github/assets/bkit-pipeline-light.svg" width="100%">
76
+ <img alt="The bkit pipeline: design, plan, build and ship, with debug fixing failed tests. Each dot is one of 40 AI agents: 10 in design, 10 in plan, 11 in build, 5 in debug and 4 in ship. It waits for your sign-off after design, after plan and before merge, merges into dev, and leaves production to you. Runs on Claude Code, Cursor, Codex and opencode." src=".github/assets/bkit-pipeline-light.svg" width="100%">
54
77
  </picture>
55
78
  </p>
56
79
 
@@ -59,38 +82,69 @@ One command per job. Each one runs a team of specialised agents, 48 in total, so
59
82
  <p align="center">
60
83
  <picture>
61
84
  <source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-fences-dark.svg">
62
- <img alt="You don't steer AI, you build fences. AI agents start out scattered at design and are funnelled through plan, build, debug and ship into production-grade code. At design and plan, reviewer agents fence the work in; from build onwards, automated checks (typecheck, lint, formatting, prose, tests) join them. Work that goes off target is sent back and retried, a failed test goes to debug, which finds the root cause, fixes it and re-runs the tests until they pass, and bkit waits for your sign-off after design, after plan and before merge." src=".github/assets/bkit-fences-light.svg" width="100%">
85
+ <img alt="You don't steer AI, you build fences. AI agents start out scattered at design and are funnelled through plan, build, debug and ship into production-grade code. At design and plan, reviewer agents fence the work in; from build onwards, automated checks from the CI template (typecheck, lint, formatting, prose, tests) join them. Work that goes off target is sent back and retried, a failed test goes to debug, which finds the root cause, fixes it and re-runs the tests until they pass, and bkit waits for your sign-off after design, after plan and before merge." src=".github/assets/bkit-fences-light.svg" width="100%">
63
86
  </picture>
64
87
  </p>
65
88
 
66
- ### You stay in control
89
+ Rules and prompts only go so far: an agent can be talked into calling something done. Reviewer agents fence in the design and the plan. From the first line of code, automated checks join them, and those can't be argued with.
67
90
 
68
- - **Decide in plain English, not code.** Before any code is written you approve two short documents: a design ("three ways to build this; we recommend this one, because…") and a plan ("these twelve steps, and how we'll know each is done").
69
- - **Nothing goes live without your OK.** The pipeline hard-stops after the design, after the plan, and before merging. bkit recommends; you decide.
70
- - **Guardrails on the AI itself.** Dangerous commands like force-pushing or rewriting history are blocked. Each agent only gets the tools its job needs, so a reviewer can read code but can't change it.
91
+ ## A CI pipeline built the way senior teams build them
92
+
93
+ CI (continuous integration) is the robot that runs every check on every change, on GitHub's servers, before anything merges. It's the strongest fence there is, and most people who start with vibe coding have never set one up. bkit ships one ready to adopt, and its workflows are built around it:
94
+
95
+ - **Ready on day one.** Two lanes run side by side: quick checks (type checking, formatting, a prose checker, a scanner for junk code AI tends to write, a workflow-file checker, and `bkit check`) and unit tests.
96
+ - **A green tick means every test ran.** One final check joins all lanes and is the only one branch protection needs. It fails if any lane failed, was skipped or cancelled, or ran zero tests, so a half-finished run can't pass as tested.
97
+ - **Grows with your project.** >20 ready-to-enable building blocks: integration tests, end-to-end tests for web, iOS and Android, database migrations (locked once merged, with security-policy checks), coverage reports, waiting for preview deploys, live checks against the deployed site, smoke and health checks, and a planner that runs only what a change affects. `bkit check` reminds you of each one until you enable or delete it.
98
+ - **Safe by default.** Every third-party action is pinned to an exact commit, the downloaded prose checker is checksum-verified, and pull-request titles never reach a script unescaped.
99
+ - **Doesn't waste minutes.** A commit that already passed isn't re-tested, and a newer push cancels the older run, except on your production branch, where a deploy must never be cut off halfway.
100
+ - **Wired into the workflows.** `/bkit-ship` merges only when the final check is green, `/bkit-debug` reads its failed logs, the cloud router starts from its result, and the gates audit flags any check that can never fail.
101
+
102
+ ## Right context at the right step
103
+
104
+ <p align="center">
105
+ <picture>
106
+ <source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-context-dark.svg">
107
+ <img alt="What it knows: right context, right step, written back as it learns. In your repo, bkit reads project docs at every step and updates them at ship; reads and writes lessons, decisions, postponed work and known bugs; writes designs and plans that later steps read; reads audit reports at plan and a code map at every step; keeps run state and stats at every step; adds skills at build and removes them at ship. Outside your repo, it reads and updates the GitHub or Linear issue at every step, searches related issues at design, plan and debug, searches the web at design and debug, reads CI runs and test reports at debug and ship, reads runtime platforms such as Sentry, Vercel, Supabase and Stripe at debug, and opens, fixes and merges the pull request." src=".github/assets/bkit-context-light.svg" width="100%">
108
+ </picture>
109
+ </p>
110
+
111
+ Most AI tools forget everything when the chat ends. bkit keeps what it knows in plain files in your repo, and each step reads what it needs and writes back what it learned:
112
+
113
+ - **Documentation that keeps itself current.** Install sets up the docs a professional project keeps: architecture, data schema, deployments, testing, security, monitoring, design system, tech stack and local setup. Agents fill them in as they work, `/bkit-ship` brings them up to date after every feature, and an index tells each agent which docs to read at each step. The docs stay current because the agents depend on them.
114
+ - **Project memory agents actually read.** Four ledgers record lessons from every fix (`docs/knowledge.jsonl`), decisions and the reasons behind them (`docs/decisions.jsonl`), work consciously postponed (`docs/deferrals.jsonl`) and known bugs (`docs/failures.jsonl`). Planning reviewers see the past bugs and postponed work closest to the new feature, debug reads the lessons first, and `/bkit-ship` checks nothing postponed was quietly dropped.
115
+ - **Evidence from outside, when it's needed.** Design searches your backlog for related issues and checks the web for feasibility. Debug pulls failed CI logs, the diff since the last green run, end-to-end reports and runtime errors. >10 ready-made connectors cover GitHub, Sentry, Vercel, Supabase, Stripe, Expo, Playwright, Maestro, Inngest, Resend, Cloud Run, Tavily web search and Serena, each easy to customise, extend or leave out. A connector that isn't set up is reported as such, never read as "all clear".
116
+ - **Progress lives in your repo, not a chat window.** Run state is saved after every step, so a crashed run resumes where it stopped, on any tool.
117
+
118
+ ## What else you get
71
119
 
72
120
  ### The quality is real
73
121
 
74
122
  - **Everything is checked by an agent that didn't write it.** An AI checking its own work tends to approve it. bkit gives every design, plan and code change to separate reviewers, each with one job (one hunts bugs, another security holes). They never see each other's verdicts, and several review groups mix models on purpose, so one model's blind spot is less likely to get past all of them.
75
- - **Broken builds fix themselves, and stay fixed.** When tests fail you don't get a wall of red text. `/bkit-debug` finds the cause, fixes it and re-runs the tests, then records the lesson so the next debug session reads it first.
76
- - **Debug starts from outside evidence, not a guess.** `/bkit-debug` gathers external context from the platforms you already use — CI, error trackers, hosting, databases, web search — so it diagnoses from the real failure rather than its memory. Ready-made templates cover the common services, and each one is easy to customise, extend or leave out.
77
- - **A green tick means every test ran.** The CI template runs test lanes side by side and fails the build if any planned lane was skipped, so a half-finished run can't pass as tested.
123
+ - **"Done" is checked by code, not taken on trust.** Every step's output is verified before the next step starts, a task is ticked only when its result really exists, and a silent TODO or skipped test blocks the merge.
124
+ - **Broken builds fix themselves, and stay fixed.** `/bkit-debug` finds the root cause before it changes anything, fixes it, re-runs the tests and records the lesson. Bugs that only show up at runtime get a dedicated mode that adds logging, fixes on evidence and removes the logging again.
125
+ - **It knows when to stop.** If a failure can't be fixed, bkit writes a clear handover and stops, instead of guessing over and over.
126
+
127
+ ### Engineering know-how, built in
128
+
129
+ - **Best model for each job, on every tool.** Each agent has its own model and thinking depth, chosen per tool and provider. Deep reasoning models do architecture and security review; quick ones write summaries. Starting a session on a cheaper model never quietly downgrades the reviewers.
130
+ - **It tests ideas before you commit to them.** When reviewers flag an unknown a design depends on, design writes throwaway probe code to settle it before you approve, and a design reviewer checks failure modes and monitoring, not just whether it can be built.
131
+ - **Big features are split up.** A plan too big for one build becomes a sequence of smaller plans, and each is re-checked against the current code right before it's built.
132
+ - **Numbers on your own work.** Every run records its time, size of change and retries in `.bkit/stats.jsonl`, and posts them to the issue next to the median of your last five runs.
133
+ - **Health checks on demand.** >30 audit checklists act like hiring a specialist for a day.
78
134
 
79
135
  ### It fits how you work
80
136
 
81
- - **Never blocked by usage limits.** Out of Claude for the week? Carry on in Cursor, Codex or opencode, or on free models on your own machine through Ollama. Same feature, same checks, nothing to set up again, because progress is saved in your repo, not in a chat window.
82
- - **Start on your laptop, check in from your phone.** A feature started at your desk can continue in a cloud session (Claude Code on the web or the Claude app, Cursor cloud agents), or start by itself when CI finishes: ship on green, debug on red. The cloud setup ships ready to adopt.
137
+ - **Never blocked by usage limits.** Out of Claude for the week? Carry on in Cursor, Codex or opencode, or on free models on your own machine through Ollama. Same feature, same checks, nothing to set up again.
138
+ - **Start on your laptop, check in from your phone.** A feature started at your desk can continue in a cloud session (Claude Code on the web or the Claude app, Cursor cloud agents, or opencode on GitHub Actions), or start by itself when CI finishes: ship on green, debug on red. The cloud setup ships ready to adopt.
83
139
  - **Run several features at once.** Each one works in its own copy of the repo (a git worktree), so they never trip over each other.
84
140
  - **Your issue tracker is the control panel.** bkit reads the GitHub or Linear issue, posts progress as it goes, moves the issue along and links the pull request.
85
141
  - **The right expertise for each feature.** When a plan needs, say, Stripe or Supabase, bkit installs a matching skill for the build and removes it when the feature ships.
86
142
 
87
- ### Engineering know-how, built in
143
+ ### You stay in control
88
144
 
89
- - **Best model for each job, on every tool.** Each agent has its own model and thinking depth, chosen per tool and provider. Deep reasoning models do architecture and security review; quick ones write summaries. Starting a session on a cheaper model never quietly downgrades the reviewers.
90
- - **Documentation that keeps itself current.** bkit sets up the docs a professional project keeps: architecture, data schema, deployments, testing, security, monitoring, design system, tech stack and local setup, each with a clear purpose. Agents fill them in as they work, `/bkit-ship` updates them after every feature, and an index tells each agent which docs to read at each step. The docs stay current because the agents depend on them.
91
- - **Project memory agents actually read.** Plain-text ledgers in your repo record lessons from every fix (`docs/knowledge.jsonl`), decisions and the reasons behind them (`docs/decisions.jsonl`), work consciously postponed (`docs/deferrals.jsonl`) and known bugs (`docs/failures.jsonl`). Agents read them before they start, and `/bkit-ship` checks nothing postponed was quietly dropped.
92
- - **Numbers on your own work.** Every run records its time, size of change and retries in `.bkit/stats.jsonl`, and posts them to the issue next to the median of your last five runs.
93
- - **Health checks on demand.** 35 audit checklists act like hiring a specialist for a day: security, privacy, accessibility, architecture, performance, database, LLM usage, cost and more.
145
+ - **Decide in plain English, not code.** Before any code is written you approve two short documents: a design ("three ways to build this; we recommend this one, because…") and a plan ("these twelve steps, and how we'll know each is done").
146
+ - **Three sign-offs, and production stays yours.** bkit stops after the design, after the plan and before merging. It merges into your `dev` branch and never touches `main`: promoting to production is always your call. Cloud mode can ship on green without you, but only for issues you've labelled `bkit:auto`, and removing the label stops it.
147
+ - **Guardrails on the AI itself.** Dangerous commands like force-pushing or rewriting history are blocked. Each agent only gets the tools its job needs.
94
148
 
95
149
  ## Templates ready to adopt
96
150
 
@@ -99,8 +153,9 @@ bkit installs only what its workflows run. Everything else, the things you or an
99
153
  <!-- prettier-ignore -->
100
154
  | Template | What it gives you |
101
155
  | --- | --- |
102
- | **CI pipeline** | Parallel test lanes (quick checks, unit, build, integration, database migrations, end-to-end), so a run takes as long as the slowest lane, not all of them added up. One final check is the only one branch protection needs. |
156
+ | **CI pipeline** | Two lanes ready to go and >20 building blocks for the rest ([above](#a-ci-pipeline-built-the-way-senior-teams-build-them)). One final check is the only one branch protection needs. |
103
157
  | **Quality checks** | Type checking, formatting, a prose checker, a scanner for junk code AI tends to write, and a workflow-file checker, wired into git hooks and CI. Your `bkit:gate:*` scripts in `package.json` define what "the checks" are, and the gates audit flags any check that can never fail. |
158
+ | **Context connectors** | >10 ready-made connectors that let `/bkit-debug` read CI, error trackers, hosting, databases, payments, email, queues and the web. |
104
159
  | **Cloud agents** | When CI finishes, a cloud agent picks up: ship on green, debug on red. No laptop needed. |
105
160
  | **Dependency updates** | Ready-made Renovate or Dependabot setups: grouped minor updates, pinned GitHub Actions, and security fixes that skip the weekly queue. |
106
161
  | **Secrets sync** | One local file holds every key. One command pushes them to Vercel, GitHub Actions, Google Cloud, Supabase and Expo; another proves every copy matches without printing a value. |
@@ -133,11 +188,14 @@ Full install, upgrade and CI setup: [`.bkit/install.md`](.bkit/install.md).
133
188
  **Do I need to know how to code?**
134
189
  No, but you do need to read a design and a plan and decide whether they're right. Setup takes a few terminal commands, or one pasted prompt.
135
190
 
191
+ **Who is it not for?**
192
+ bkit is heavier than a single prompt. For a one-off script or a quick experiment, just ask your AI. bkit pays off on a project you'll keep changing and want to trust.
193
+
136
194
  **What does it cost?**
137
195
  bkit is free for personal use, non-profits and small businesses (fewer than 100 people and under US$1M revenue); larger companies need a commercial licence ([License](#license)). It runs on AI subscriptions you already have (Claude, Cursor, ChatGPT for Codex), on pay-as-you-go providers through opencode, or on free local models. Several agents reviewing in parallel uses more of your quota than a single chat; that's the price of the second opinions.
138
196
 
139
197
  **Can it break my live site?**
140
- Not without your sign-off. Work happens in a separate copy of the repo, goes through a pull request, must pass every test, and merges only when you approve.
198
+ Not without your sign-off. Work happens in a separate copy of the repo, goes through a pull request, must pass every test, and merges into `dev`, never `main`.
141
199
 
142
200
  **Which issue tracker?**
143
201
  GitHub Issues or Linear.
@@ -147,11 +205,12 @@ GitHub Issues or Linear.
147
205
 
148
206
  - **Isolation.** Every run gets its own git worktree; a per-feature lock blocks duplicate runs of the same feature, and a short repo-wide lock serialises only the moments that write to `dev`.
149
207
  - **Resume from state, not session.** Run state lives in `status.jsonl` and `docs/plans/`. A crashed or interrupted run resumes from its last completed step, on any host.
150
- - **Engine.** The `bkit` CLI is TypeScript in [`.bkit/core/engine/`](.bkit/core/engine/), built to `dist/`. `commands/` holds what you type; `install/`, `render/`, `checks/`, `ledgers/` and `shared/` hold the code underneath; `audits/` holds the tests that read shipped text.
208
+ - **Mechanical step gates.** `bkit steps finish` checks each step's verdict and artifacts before the workflow moves on; build ticks a task only on a confirmed artifact; ship's deferred sweep fails the merge on an unplanned gap.
209
+ - **Engine.** The `bkit` CLI is TypeScript in [`.bkit/core/engine/`](.bkit/core/engine/), built to `dist/`, covered by >3,000 tests. `commands/` holds what you type; `install/`, `render/`, `checks/`, `ledgers/` and `shared/` hold the code underneath; `audits/` holds the tests that read shipped text.
151
210
  - **One source, every host.** `.bkit/` renders `.claude/`, `.cursor/`, `.codex/` and `.opencode/`. `bkit check` is the CI drift gate.
152
211
  - **Reviewer independence.** Parallel reviewers can't read sibling output. Design brainstorm, design review and plan scope-check groups also cross models (Opus + Sonnet on Claude; Grok + Composer on Cursor); depth-sensitive lenses (plan review, build challenge) stay on the top tier.
153
212
  - **Per-agent pins.** Model and effort per agent, per provider ([`.bkit/prompts.md`](.bkit/prompts.md) § Models), immune to the session default.
154
- - **Against the literature.** bkit fully implements 12 of the 22 patterns in Antonio Gulli's _Agentic Design Patterns_, partly implements 8 (scoped to shipping code), leaves 2 out by design, and goes beyond the book in 7 places. Full mapping and every agent in execution order: [`.bkit/comparison.md`](.bkit/comparison.md).
213
+ - **Against the literature.** bkit fully implements 13 of the 22 patterns in Antonio Gulli's _Agentic Design Patterns_, partly implements 7 (scoped to shipping code), leaves 2 out by design, and goes beyond the book in 8 places. Full mapping and every agent in execution order: [`.bkit/comparison.md`](.bkit/comparison.md).
155
214
 
156
215
  </details>
157
216
 
@@ -160,7 +219,7 @@ GitHub Issues or Linear.
160
219
  <!-- prettier-ignore -->
161
220
  | Read | For |
162
221
  | --- | --- |
163
- | [`.bkit/install.md`](.bkit/install.md) | Install, upgrade, token and CI auth, uninstall, recovery |
222
+ | [`.bkit/install.md`](.bkit/install.md) | Install, upgrade, CI auth, uninstall, recovery |
164
223
  | [`.bkit/README.md`](.bkit/README.md) | Day-to-day use: running workflows, environment, tracker setup, CLI |
165
224
  | [`.bkit/workflows.md`](.bkit/workflows.md) | Every workflow step, verdict and contract |
166
225
  | [`.bkit/providers.md`](.bkit/providers.md) | Tool and provider differences, model pins |
@@ -228,7 +228,7 @@ export function buildGithubProjectAdvisory(cwd) {
228
228
  detect: `GitHub tracker is active but Projects v2 board status sync is not fully configured${missingPhrase}. ` +
229
229
  "Board sync silently no-ops — workflows never reflect phase on the project board.",
230
230
  action: "Board status sync is optional (workflows never gate on it) but invisible when half-configured. All three prerequisites are required:\n\n" +
231
- "1. Add `bkit.githubProject` to package.json (org-owned board only — fine-grained PATs cannot reach user-owned projects):\n\n" +
231
+ "1. Add `bkit.githubProject` to package.json (org-owned board only — fine-grained PATs cannot reach user-owned projects, nor span orgs; use a classic PAT with `project` to cover more than one owner):\n\n" +
232
232
  ' "bkit": {\n' +
233
233
  ' "githubProject": {\n' +
234
234
  ' "owner": "<org>", "number": <project-number>,\n' +
@@ -269,7 +269,7 @@ export function runPostInstallCheck(preflightAdvisories, cwd = process.cwd(), su
269
269
  id: "gh-mcp-token-unset-shell",
270
270
  severity: "advisory",
271
271
  detect: "BKIT_GH_TOKEN is not set in the shell environment (undefined). The GitHub MCP server authenticates with `Authorization: Bearer ${BKIT_GH_TOKEN}` — without it, every tracker, PR, and board MCP call fails to connect.",
272
- action: "Set BKIT_GH_TOKEN in .bkit/.env (canonical local-secrets file, gitignored), then `direnv allow` and restart your editor so MCP servers pick it up:\n\n cp .bkit/.env.example .bkit/.env # if not already done\n # edit .bkit/.env — set BKIT_GH_TOKEN=<fine-grained PAT>\n direnv allow\n\nThe PAT needs Contents, Pull requests, Issues, and Actions read & write (plus organization-scoped Projects read & write if you use board sync). Generate at: https://github.com/settings/tokens. In cloud sessions (Claude Code web / Cursor Background Agents) set BKIT_GH_TOKEN in the dashboard env vars instead — repo files are not read for secrets there.",
272
+ action: "Set BKIT_GH_TOKEN in .bkit/.env (canonical local-secrets file, gitignored), then `direnv allow` and restart your editor so MCP servers pick it up:\n\n cp .bkit/.env.example .bkit/.env # if not already done\n # edit .bkit/.env — set BKIT_GH_TOKEN=<PAT>\n direnv allow\n\nUse a fine-grained PAT when every target repo sits under one owner (Contents, Pull requests, Issues, and Actions read & write, plus organization-scoped Projects read & write if you use board sync); use a classic PAT when one token must span owners (scopes repo / workflow / read:org / project / security_events). Generate at: https://github.com/settings/personal-access-tokens (fine-grained) or https://github.com/settings/tokens (classic). In cloud sessions (Claude Code web / Cursor Background Agents) set BKIT_GH_TOKEN in the dashboard env vars instead — repo files are not read for secrets there.",
273
273
  });
274
274
  }
275
275
  else if (ghMcpTokenStatus === "empty") {
@@ -277,7 +277,7 @@ export function runPostInstallCheck(preflightAdvisories, cwd = process.cwd(), su
277
277
  id: "gh-mcp-token-empty-shell",
278
278
  severity: "advisory",
279
279
  detect: 'BKIT_GH_TOKEN is set to an empty string (BKIT_GH_TOKEN=""). The GitHub MCP server sends an empty bearer token and fails to authenticate — distinct from unset, same effect.',
280
- action: "Set a non-empty BKIT_GH_TOKEN in .bkit/.env (fine-grained PAT with Contents / Pull requests / Issues / Actions read & write), then `direnv allow` and restart your editor so MCP servers reload.",
280
+ action: "Set a non-empty BKIT_GH_TOKEN in .bkit/.env (fine-grained PAT for one owner, or classic across owners; Contents / Pull requests / Issues / Actions read & write), then `direnv allow` and restart your editor so MCP servers reload.",
281
281
  });
282
282
  }
283
283
  }
@@ -55,7 +55,7 @@ export function detectBlankDotenvKeys(cwd, tracker = "linear") {
55
55
  const REQUIRED_KEYS = [
56
56
  {
57
57
  key: "BKIT_GH_TOKEN",
58
- description: "fine-grained PAT for the GitHub MCP server (Contents, Pull requests, Issues, Actions, Workflows, Metadata — read/write)",
58
+ description: "fine-grained PAT for the GitHub MCP server (Contents, Pull requests, Issues, Actions, Workflows, Metadata — read/write), or a classic PAT when one token must span owners",
59
59
  },
60
60
  // BKIT_LINEAR_API_KEY is required only under the Linear tracker.
61
61
  ...(tracker === "linear"
@@ -24,7 +24,7 @@ import * as readline from "node:readline";
24
24
  import { stripManagedBlock, detectMarkerStyle } from "../../install/managed-block.js";
25
25
  import { readTemplate } from "../../render/parts.js";
26
26
  import { getInstallManifest, } from "../../install/manifest.js";
27
- import { isConsumerModified, readBkitVersion } from "../../install/version-file.js";
27
+ import { isConsumerModified, mergeCanonicalHashes, readBkitVersion, writeBkitVersion, } from "../../install/version-file.js";
28
28
  import { getPkgRoot, getSharedRoot, findTemplateSource, TEMPLATE_COPIES_DIR, } from "../../shared/package-roots.js";
29
29
  import { PAYLOAD_LINKS } from "../../install/payload-links.js";
30
30
  import { removeOpencodeProviderBlock, renderOpencodeJson } from "../../install/modules/opencode.js";
@@ -717,6 +717,26 @@ export async function runUninstall(modules, ctx) {
717
717
  }
718
718
  }
719
719
  }
720
+ // Targeted (non-core) uninstall: `.bkit/version` stays (the modules that remain read it),
721
+ // but its canonicalHashes still list every path this run deleted — absent entries that
722
+ // `mergeCanonicalHashes` prunes. Left in place, the very next `bkit check` (a dry-run
723
+ // install whose core postDispatch prunes the same absent paths) reports write-drift on
724
+ // `.bkit/version` and fails the CI gate. Recompute and rewrite here so the on-disk manifest
725
+ // already matches what the next check would produce. A full/core uninstall deletes the file
726
+ // earlier instead (zero footprint) and never reaches this branch.
727
+ if (!moduleList.includes("core")) {
728
+ const versionFile = path.join(ctx.cwd, ".bkit", "version");
729
+ const existing = readBkitVersion(versionFile);
730
+ if (existing) {
731
+ const { canonicalHashes, pruned } = mergeCanonicalHashes(ctx.cwd, existing.canonicalHashes, {});
732
+ if (pruned > 0) {
733
+ console.log(`${ctx.logPrefix}${ctx.dryRun ? " [dry-run]" : ""} update version pin: .bkit/version (pruned ${pruned})`);
734
+ if (!ctx.dryRun) {
735
+ writeBkitVersion(versionFile, { ...existing, canonicalHashes });
736
+ }
737
+ }
738
+ }
739
+ }
720
740
  return result;
721
741
  }
722
742
  // ---------------------------------------------------------------------------
@@ -34,7 +34,10 @@ export const SESSION_HIJACK_KEYS = [
34
34
  // placeholder ONLY when absent from the resolved `.envrc` set — a present value
35
35
  // (e.g. BKIT_GH_TOKEN already in `.bkit/.env`) keeps its real resolved value.
36
36
  const BASELINE_TOKEN_PLACEHOLDERS = [
37
- ["BKIT_GH_TOKEN", "<fine-grained PAT — see .bkit/cloud.md § BKIT_GH_TOKEN permissions>"],
37
+ [
38
+ "BKIT_GH_TOKEN",
39
+ "<PAT — fine-grained one owner / classic across owners; see .bkit/cloud.md § BKIT_GH_TOKEN token permissions>",
40
+ ],
38
41
  ];
39
42
  // Earlier-compaction override — a bkit constant, not a secret. Appended to the
40
43
  // block when not already resolved from a source file. Claude-harness-only knob —
@@ -89,8 +89,8 @@ export function runCloudModule(ctx) {
89
89
  "IN CLAUDE APP (claude.ai/code → environment selector → + Add environment):\n" +
90
90
  " - Name: the repo name (e.g. `acme-web`) — one environment per repo, since secrets are per-repo.\n" +
91
91
  " - Setup script: paste from bkit's `cloud.md` § Setup script (installs vale + gh + corepack-pinned pnpm — exact versions live in cloud.md, not duplicated here).\n" +
92
- " - Environment variables: `BKIT_GH_TOKEN` (fine-grained PAT for GitHub MCP), `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70`.\n" +
93
- " - Tracker env vars (GitHub): No tracker PAT needed. Run `gh auth login` once for CLI surface. MCP auth is browser OAuth (automatic on first tool call). Set `BKIT_GH_TOKEN` (fine-grained PAT for GitHub MCP server).\n" +
92
+ " - Environment variables: `BKIT_GH_TOKEN` (fine-grained for one owner, classic across owners — GitHub MCP), `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70`.\n" +
93
+ " - Tracker env vars (GitHub): No tracker PAT needed. Run `gh auth login` once for CLI surface. MCP auth is browser OAuth (automatic on first tool call). Set `BKIT_GH_TOKEN` (fine-grained for one owner, classic across owners — GitHub MCP server).\n" +
94
94
  " - Network access: `Trusted` (default). One environment per repo (secrets differ per repo); the setup script + variable *names* are identical across repos, only the values change. See cloud.md § Sharing across repos → Claude.",
95
95
  });
96
96
  }
@@ -212,10 +212,11 @@ const OPENCODE_PROVIDER_BASE_URL_SENTINEL = "@@OPENCODE_PROVIDER_BASE_URL@@";
212
212
  * Resolves the @@OPENCODE_TRACKER_MCP@@ sentinel into the correct mcpServers entry
213
213
  * and fills in provider-specific fields.
214
214
  *
215
- * Also injects `curl *{domain}*` / `wget *{domain}*` **allow** rules (after the
216
- * template's `curl *` / `wget *` ask) for {@link resolveNetworkAllowlist} so
217
- * context-fetch / provider hosts do not prompt (OpenCode bash is last-match-wins), and
218
- * `<server>_*` allows for the consumer's `mcp-servers` block.
215
+ * Also injects derived **allow** rules for {@link resolveNetworkAllowlist} so
216
+ * context-fetch / provider hosts do not prompt on either fetch surface: `curl *{domain}*` /
217
+ * `wget *{domain}*` after the template's `curl *` / `wget *` ask (OpenCode bash is
218
+ * last-match-wins), and `*{domain}*` into the `permission.webfetch` URL map (after its
219
+ * `"*": "ask"`). Adds `<server>_*` allows for the consumer's `mcp-servers` block.
219
220
  */
220
221
  export function renderOpencodeJson(templatePath, tracker, provider, cwd = process.cwd()) {
221
222
  const raw = fs.readFileSync(templatePath, "utf-8");
@@ -229,10 +230,14 @@ export function renderOpencodeJson(templatePath, tracker, provider, cwd = proces
229
230
  // opencode's MCP schema differs from Claude/Cursor: remote servers use type "remote"
230
231
  // (NOT "http" — not in opencode's enum, which makes the whole config invalid) and read
231
232
  // secrets via {env:VAR} (NOT shell ${VAR}). See https://opencode.ai/config.json.
233
+ // github: "oauth": false disables opencode's automatic OAuth. api.githubcopilot.com/mcp/
234
+ // authenticates via the Authorization header and has no OAuth DCR, so a stale/empty
235
+ // {env:BKIT_GH_TOKEN} would otherwise surface as a "sign in" prompt whose flow fails with
236
+ // "dynamic auth not supported" instead of a clear 401. See opencode.ai/docs/mcp-servers.
232
237
  let mcpEntry;
233
238
  if (tracker === "github") {
234
239
  mcpEntry =
235
- '"github": { "type": "remote", "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer {env:BKIT_GH_TOKEN}", "X-MCP-Toolsets": "context,issues,pull_requests,repos,users,projects" } }';
240
+ '"github": { "type": "remote", "url": "https://api.githubcopilot.com/mcp/", "oauth": false, "headers": { "Authorization": "Bearer {env:BKIT_GH_TOKEN}", "X-MCP-Toolsets": "context,issues,pull_requests,repos,users,projects" } }';
236
241
  }
237
242
  else if (tracker === "linear") {
238
243
  mcpEntry = '"linear": { "type": "remote", "url": "https://mcp.linear.app/mcp" }';
@@ -287,9 +292,16 @@ export function renderOpencodeJson(templatePath, tracker, provider, cwd = proces
287
292
  }
288
293
  }
289
294
  /**
290
- * Append curl/wget domain allows after template ask rules (OpenCode last-match-wins),
291
- * and one `<server>_*` allow per declared MCP server — opencode names MCP tools
292
- * `<server>_<tool>` and matches permission keys as globs against the tool name.
295
+ * Append derived allows for the consumer's resolved network allowlist (OpenCode
296
+ * last-match-wins), and one `<server>_*` allow per declared MCP server — opencode names
297
+ * MCP tools `<server>_<tool>` and matches permission keys as globs against the tool name.
298
+ *
299
+ * The allowlist is applied to BOTH fetch surfaces, so an allowlisted host does not prompt
300
+ * whichever path the agent takes:
301
+ * - fetch tool — `permission.webfetch` is a URL-keyed map (`{ "*": "ask" }` from the
302
+ * template); opencode matches the resource against the URL, so `*{base}*` allows it;
303
+ * - shell fetch — `permission.bash` gains `curl *{base}*` / `wget *{base}*` after the
304
+ * template's `curl *` / `wget *` ask.
293
305
  */
294
306
  function injectOpencodeDerivedAllows(parsed, cwd) {
295
307
  const permission = parsed.permission;
@@ -298,12 +310,20 @@ function injectOpencodeDerivedAllows(parsed, cwd) {
298
310
  for (const server of extractMcpServers(cwd)) {
299
311
  permission[`${server}_*`] = "allow";
300
312
  }
301
- if (typeof permission.bash !== "object" || permission.bash === null)
302
- return;
303
- const bash = permission.bash;
304
- for (const base of networkAllowlistBases(resolveNetworkAllowlist(cwd))) {
305
- bash[`curl *${base}*`] = "allow";
306
- bash[`wget *${base}*`] = "allow";
313
+ const bases = networkAllowlistBases(resolveNetworkAllowlist(cwd));
314
+ if (typeof permission.bash === "object" && permission.bash !== null) {
315
+ const bash = permission.bash;
316
+ for (const base of bases) {
317
+ bash[`curl *${base}*`] = "allow";
318
+ bash[`wget *${base}*`] = "allow";
319
+ }
320
+ }
321
+ // Fetch tool — opencode matches the webfetch resource against the requested URL.
322
+ if (typeof permission.webfetch === "object" && permission.webfetch !== null) {
323
+ const webfetch = permission.webfetch;
324
+ for (const base of bases) {
325
+ webfetch[`*${base}*`] = "allow";
326
+ }
307
327
  }
308
328
  }
309
329
  /**
package/package.json CHANGED
@@ -1,8 +1,30 @@
1
1
  {
2
2
  "name": "@cbartens/bkit",
3
- "version": "5.0.1",
3
+ "version": "5.0.2",
4
4
  "private": false,
5
- "description": "Agent-stack consolidation CLI.",
5
+ "description": "From vibe coding to production code. A senior engineering team's process, ready-made: AI agents design, plan, build, review, fix and ship your features on Claude Code, Cursor, Codex and opencode.",
6
+ "keywords": [
7
+ "ai-agents",
8
+ "agentic-coding",
9
+ "agentic-workflow",
10
+ "multi-agent",
11
+ "vibe-coding",
12
+ "claude-code",
13
+ "cursor",
14
+ "codex",
15
+ "opencode",
16
+ "ai-code-review",
17
+ "code-review",
18
+ "developer-tools",
19
+ "workflow-automation",
20
+ "ci-cd",
21
+ "github-actions",
22
+ "linear",
23
+ "llm",
24
+ "cli"
25
+ ],
26
+ "homepage": "https://github.com/cbartens/bkit#readme",
27
+ "bugs": "https://github.com/cbartens/bkit/issues",
6
28
  "type": "module",
7
29
  "bin": {
8
30
  "bkit": "./dist/cli.js"