@mayurdluffy/ccwf 0.0.0-stage → 0.1.0

package/templates/docs/agents/domain.md

@@ -0,0 +1,52 @@
+# Domain Docs
+
+How the engineering skills should consume this repo's domain documentation when exploring the codebase.
+
+## Before exploring, read these
+
+- **`docs/GLOSSARY.md`** (this repo keeps its glossary in `docs/`), or
+- **`GLOSSARY-MAP.md`** at the repo root if it exists: it points at one `GLOSSARY.md` per context. Read each one relevant to the topic.
+- **`docs/adr/`**: read ADRs that touch the area you're about to work in. In multi-context repos, also check `src/<context>/docs/adr/` for context-scoped decisions.
+
+If any of these files don't exist, **proceed silently**. Don't flag their absence; don't suggest creating them upfront. The `/domain-modeling` skill (reached via `/grill-with-docs` and `/improve-codebase-architecture`) creates them lazily when terms or decisions actually get resolved.
+
+## File structure
+
+Single-context repo (most repos):
+
+```
+/
+├── docs/
+│   ├── GLOSSARY.md
+│   └── adr/
+│       ├── 0001-event-sourced-orders.md
+│       └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+Multi-context repo (presence of `GLOSSARY-MAP.md` at the root):
+
+```
+/
+├── GLOSSARY-MAP.md
+├── docs/adr/                          ← system-wide decisions
+└── src/
+    ├── ordering/
+    │   ├── GLOSSARY.md
+    │   └── docs/adr/                  ← context-specific decisions
+    └── billing/
+        ├── GLOSSARY.md
+        └── docs/adr/
+```
+
+## Use the glossary's vocabulary
+
+When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in `docs/GLOSSARY.md`. Don't drift to synonyms the glossary explicitly avoids.
+
+If the concept you need isn't in the glossary yet, that's a signal: either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for `/domain-modeling`).
+
+## Flag ADR conflicts
+
+If your output contradicts an existing ADR, surface it explicitly rather than silently overriding:
+
+> _Contradicts ADR-0007 (event-sourced orders), but worth reopening because…_

package/templates/docs/agents/issue-tracker.md

@@ -0,0 +1,30 @@
+# Issue tracker: Local Markdown
+
+Issues and specs for this repo live as markdown files in `.scratch/`.
+
+## Conventions
+
+- One feature per directory: `.scratch/<feature-slug>/`
+- The spec is `.scratch/<feature-slug>/spec.md`
+- Implementation issues are one file per ticket at `.scratch/<feature-slug>/issues/<NN>-<slug>.md`, numbered from `01`, never a single combined tickets file
+- Triage state is recorded as a `Status:` line near the top of each issue file (see `triage-labels.md` for the role strings)
+- Comments and conversation history append to the bottom of the file under a `## Comments` heading
+
+## When a skill says "publish to the issue tracker"
+
+Create a new file under `.scratch/<feature-slug>/` (creating the directory if needed).
+
+## When a skill says "fetch the relevant ticket"
+
+Read the file at the referenced path. The user will normally pass the path or the issue number directly.
+
+## Wayfinding operations
+
+Used by `/wayfinder`. The **map** is a file with one **child** file per ticket.
+
+- **Map**: `.scratch/<effort>/map.md` (the Notes / Decisions-so-far / Fog body).
+- **Child ticket**: `.scratch/<effort>/issues/NN-<slug>.md`, numbered from `01`, with the question in the body. A `Type:` line records the ticket type (`research`/`prototype`/`grilling`/`task`); a `Status:` line records `claimed`/`resolved`.
+- **Blocking**: a `Blocked by: NN, NN` line near the top. A ticket is unblocked when every file it lists is `resolved`.
+- **Frontier**: scan `.scratch/<effort>/issues/` for files that are open, unblocked, and unclaimed; first by number wins.
+- **Claim**: set `Status: claimed` and save before any work.
+- **Resolve**: append the answer under an `## Answer` heading, set `Status: resolved`, then append a context pointer (gist + link) to the map's Decisions-so-far in `map.md`.

package/templates/docs/agents/setup.md

@@ -0,0 +1,48 @@
+# Setup: tools and skills
+
+`npx @mayurdluffy/ccwf init` checks everything below, shows what is missing, and installs it after one confirmation. `--yes` skips the confirmation: it runs vendor install scripts from the network and installs skills from the current head of third-party repos. This page says what each piece is and how to install it by hand if the script fails. Supported: macOS and Linux; Claude Code, Codex and Cursor.
+
+## 1. Before `ccwf`: codebase-memory (once per repo)
+
+`ccwf` does not install the code-graph server. Do it first with the companion CLI, from the repo root:
+
+```bash
+npx @mayurdluffy/cbm-cli install --agents claude,codex,cursor
+```
+
+Then ask your coding agent: "call `index_status` from the codebase-memory MCP and tell me the result." If it answers with a project name and node count, it works. Then run `ccwf init` (or `npx @mayurdluffy/ccwf sync` if you already did): `ccwf` detects `.codebase-memory/cbm-server.sh` and adds the graph-first navigation rules.
+
+Rules: one cache for all repos (never set `CBM_CACHE_DIR` per repo), no global CBM server entries. Stray global entries: `npx @mayurdluffy/cbm-cli clean-global`.
+
+## 2. Machine setup (done by `ccwf init`, once per computer)
+
+| Piece | Why | By hand |
+|---|---|---|
+| User-level skills: `mattpocock/skills` (pinned list in `ccwf`) and `vercel-labs/skills` `find-skills` | the planning skills (`grill-with-docs`, `to-spec`, `to-tickets`, `tdd`, `code-review`, ...) | `npx -y skills add mattpocock/skills -g -a claude-code codex cursor -s <names> -y` |
+| `agent-browser` | browser automation for `verify-ui` | `npm i -g agent-browser && agent-browser install` (Linux: add `--with-deps`) |
+| `herdr` + `hc` | terminal tabs for worker agents (`orchestrate-workers`) | `curl -fsSL https://releases.herdr.dev/app/install.sh \| sh`; check with `hc --version` |
+| `gh`, `ffmpeg` | PRs; screen recordings of bugs | macOS: `brew install gh ffmpeg`; Linux: your package manager |
+| `claude`, `codex`, `cursor-agent` (those you use) | the coding agents | `curl -fsSL https://claude.ai/install.sh \| bash`; `curl -fsSL https://chatgpt.com/codex/install.sh \| sh`; `curl https://cursor.com/install -fsS \| bash` |
+| Node LTS + Google Chrome | `chrome-devtools` MCP (runs through `npx`) | install from nodejs.org / google.com/chrome |
+| Codex project trust | Codex ignores a repo's `.codex/config.toml` until trusted | add `[projects."<repo path>"]` with `trust_level = "trusted"` to `~/.codex/config.toml` |
+
+Log in once per agent (not scriptable): `claude`, `codex login`, `cursor-agent login`, `gh auth login`.
+
+## 3. What `ccwf init` wrote into the repo
+
+- `.agents/skills/` — `commit`, `agent-browser`, `verify-ui`, `orchestrate-workers` (Claude reaches them through `.claude/skills/` symlinks).
+- `AGENTS.md` — rule sections between `<!-- ccwf:begin ... -->` markers (edit around them, not inside); `CLAUDE.md` imports it.
+- Agent configs: `.mcp.json`, `.codex/config.toml`, `.cursor/mcp.json`, `.cursor/cli.json`, `.claude/settings.json`.
+- `.cursor/cli.json` is the Cursor allowlist: listed commands run without asking, including `node`, `npx` and `curl`. The allow and deny lists are merged, so an entry you remove comes back on `update`.
+- Empty docs: `docs/GLOSSARY.md`, `DECISIONS.md`, `FEATURES.md`, `BACKLOG.md`, `adr/`, `.agent-memory/MEMORY.md`.
+- `.ccwf.json` — what was installed and the hash of every file `ccwf` wrote. Commit it.
+
+## 4. Settings skills ask for
+
+`verify-ui` asks on first use for the dev server URL and the sites agent-browser may visit, and stores them in `.agents/skills/verify-ui/verify-ui.conf`. Run `npx @mayurdluffy/ccwf sync` after editing it.
+
+## 5. Keeping it healthy
+
+- `npx @mayurdluffy/ccwf doctor` — checks tools, skills and files; offers to fix.
+- `npx @mayurdluffy/ccwf update` — re-render from a newer `ccwf`; files you edited are skipped.
+- `npx @mayurdluffy/ccwf eject <skill>` — stop `ccwf` from managing a skill you changed.

package/templates/docs/agents/triage-labels.md

@@ -0,0 +1,15 @@
+# Triage Labels
+
+The skills speak in terms of five canonical triage roles. This file maps those roles to the actual label strings used in this repo's issue tracker.
+
+| Label in mattpocock/skills | Label in our tracker | Meaning                                  |
+| -------------------------- | -------------------- | ---------------------------------------- |
+| `needs-triage`             | `needs-triage`       | Maintainer needs to evaluate this issue  |
+| `needs-info`               | `needs-info`         | Waiting on reporter for more information |
+| `ready-for-agent`          | `ready-for-agent`    | Fully specified, ready for an AFK agent  |
+| `ready-for-human`          | `ready-for-human`    | Requires human implementation            |
+| `wontfix`                  | `wontfix`            | Will not be actioned                     |
+
+When a skill mentions a role (e.g. "apply the AFK-ready triage label"), use the corresponding label string from this table.
+
+Edit the "Label in our tracker" column to match whatever vocabulary you actually use.

package/templates/docs/agents/workflow.md

@@ -0,0 +1,58 @@
+# Workflow: from idea to committed code
+
+How work flows in a repo set up with `@mayurdluffy/ccwf`. Every step is a skill; each leaves a file behind, so any session (or any coding agent) can pick up where the last one stopped. Tools and skills must be installed first: see `setup.md`.
+
+```
+idea ──► grill-with-docs ──► to-spec ──► to-tickets ──► orchestrate-workers ──► done
+          (decide)           (write)     (split)        (build, verify, review, commit)
+```
+
+## 1. Decide: `/grill-with-docs`
+
+Start with a rough idea. The coding agent interviews you in rounds (numbered questions, each with its recommended answer), checks facts in the code itself, and writes the project's language and decisions down as they are settled:
+
+- `docs/GLOSSARY.md` — terms, as they are resolved.
+- `docs/adr/` — only for decisions that are hard to reverse, surprising and a real trade-off.
+- `docs/DECISIONS.md` — every question asked and your answer, in your words.
+- `docs/BACKLOG.md` — anything you defer.
+
+Say "yes" to accept a recommendation. The session ends when nothing is left open and you confirm.
+
+## 2. Write: `/to-spec`
+
+Turns the conversation into a spec file: `.scratch/<feature>/spec.md`. No new interview.
+
+## 3. Split: `/to-tickets`
+
+Breaks the spec into small vertical tickets, one file each: `.scratch/<feature>/issues/<NN>-<slug>.md`, with a `Status:` line and `Blocked by:` edges. Labels and tracker rules: `issue-tracker.md`, `triage-labels.md`. Add the feature to `docs/FEATURES.md` as Planned.
+
+## 4. Build: `/orchestrate-workers`
+
+One coding agent is the **orchestrator**; it does not write feature code. Up to four **workers** (Claude Code, Codex or Cursor, any mix) each take one ticket in a herdr pane, test-first. The orchestrator loop:
+
+1. Confirm the worker roster (`.agents/skills/orchestrate-workers/workers.conf`) with you.
+2. Pick a wave of unblocked tickets that don't edit the same files; assign one per worker.
+3. Wait for each worker; approve safe permission prompts.
+4. Review each finished ticket (standards and spec), send defects back to the same worker.
+5. `verify-ui` checks anything visible in a real browser (page health, scenario files per ticket).
+6. **You check** anything a person should judge (UI, security) and say go.
+7. Commit with the `commit` skill (Conventional Commits, one per ticket), mark tickets done, update `docs/FEATURES.md`, start the next wave.
+
+State lives in the ticket `Status:` lines and `.scratch/<feature>/progress.md`, so a new session resumes from the files.
+
+## Along the way
+
+| Need | Use |
+|---|---|
+| Find code fast | graph first (codebase-memory), then Grep/Read |
+| See the UI | `verify-ui` (`probe.sh`, `run.sh`), `agent-browser` by hand |
+| A bug, slowness, a regression | `/diagnosing-bugs` |
+| New feature test-first | `/tdd` |
+| Review a branch or PR | `/code-review`, `/pr` |
+| Remember something for every agent | ask it to write `.agent-memory/` |
+
+## Rules of thumb
+
+- Never commit or push without your say-so.
+- Answers to questions go in `docs/DECISIONS.md` before work continues.
+- Settings a skill needs (for example the dev URL for `verify-ui`) are asked once and stored in the skill's `.conf` file; `npx @mayurdluffy/ccwf sync` pushes shared values into the agent configs.

package/templates/machine.json

@@ -0,0 +1,47 @@
+{
+  "skills": {
+    "mattpocock/skills": [
+      "ask-matt",
+      "chief-of-staff",
+      "claude-handoff",
+      "code-review",
+      "codebase-design",
+      "diagnosing-bugs",
+      "domain-modeling",
+      "git-guardrails-claude-code",
+      "grill-me",
+      "grill-with-docs",
+      "grilling",
+      "handoff",
+      "implement",
+      "implement-spec",
+      "improve-codebase-architecture",
+      "loop-me",
+      "migrate-to-shoehorn",
+      "pr",
+      "prototype",
+      "research",
+      "retro",
+      "scaffold-exercises",
+      "setup-matt-pocock-skills",
+      "setup-pre-commit",
+      "setup-ts-deep-modules",
+      "tdd",
+      "teach",
+      "to-questionnaire",
+      "to-spec",
+      "to-tickets",
+      "triage",
+      "wait-what",
+      "wayfinder",
+      "wizard",
+      "writing-beats",
+      "writing-for-agents",
+      "writing-fragments",
+      "writing-shape"
+    ],
+    "vercel-labs/skills": [
+      "find-skills"
+    ]
+  }
+}

package/templates/skills/agent-browser/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 Vercel Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

package/templates/skills/agent-browser/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: agent-browser
+description: Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.
+allowed-tools: Bash(agent-browser:*)
+hidden: true
+---
+
+# agent-browser
+
+Fast browser automation CLI for AI agents. Chrome/Chromium via CDP with accessibility-tree snapshots and compact `@eN` element refs.
+
+Install: `npm i -g agent-browser && agent-browser install`
+
+## Start here
+
+This file is a discovery stub, not the usage guide. Before running any `agent-browser` command, load the actual workflow content from the CLI:
+
+```bash
+agent-browser skills get core             # start here: the loop, waits, common tasks, troubleshooting
+```
+
+The core guide ends with a table of references to load for detailed commands and flags. Use `agent-browser skills get core --full` only when you need every reference at once; it is several times larger.
+
+The CLI serves skill content that matches the installed version. This stub cannot change between releases, which is why it only points at `skills get core`.
+
+## Specialized skills
+
+Load a specialized skill when the task falls outside browser web pages:
+
+```bash
+agent-browser skills get electron          # Electron desktop apps (VS Code, Slack, Discord, Figma, ...)
+agent-browser skills get slack             # Slack workspace automation
+agent-browser skills get dogfood           # Exploratory testing / QA / bug hunts
+agent-browser skills get derive-client     # Record a HAR, derive a standalone API client for a site
+agent-browser skills get webmcp-gen        # Build and validate WebMCP tools for a page
+agent-browser skills get modern-web-guidance  # Apply Modern Web Guidance, then verify the page
+agent-browser skills get vercel-sandbox    # agent-browser inside Vercel Sandbox microVMs
+agent-browser skills get protected-vercel-deployments  # Access protected Vercel deployments
+agent-browser skills get agentcore         # AWS Bedrock AgentCore cloud browsers
+```
+
+Run `agent-browser skills list` to see everything available on the installed version.
+
+## Why agent-browser
+
+- Fast native Rust CLI, not a Node.js wrapper
+- Works with any AI agent (Cursor, Claude Code, Codex, Continue, Windsurf, etc.)
+- Chrome/Chromium via CDP with no Playwright or Puppeteer dependency
+- Accessibility-tree snapshots with element refs for reliable interaction
+- Sessions, authentication vault, state persistence, video recording
+- Specialized skills for Electron apps, Slack, exploratory testing, cloud providers

package/templates/skills/commit/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: commit
+description: Prepare and create a clean, production-grade git commit (Conventional Commits, atomic, safe staging, verified). Use whenever the user says "commit", "commit this", "prepare a commit", "write a commit message", "stage and commit", "save these changes to git", or finishes a task and wants it recorded — even if they never mention conventional commits. Does not push, open PRs (use the pr skill), or rewrite history.
+---
+
+# commit
+
+Commits are the project's long-term memory: reviewers, `git bisect`, `git revert` and release notes all depend on each commit being one logical change with a message that explains *why*. Work through these steps in order.
+
+## 1. Inspect
+
+Run `git status --short`, `git diff --stat`, `git diff` and `git diff --staged`, plus `git log -5 --oneline` to match the repo's existing style (it errors on a repo with no commits yet; that is fine, just follow this guide). If this is not a git repo, say so and stop. If there is nothing to commit, say so and stop.
+
+## 2. Safety screen (before staging anything)
+
+Do not stage: secrets or credentials (`.env*`, keys, tokens, anything matching `password|secret|token|api_key` in the diff), `node_modules/`, build output (`dist/`), logs, HAR files (they contain auth headers), and stray screenshots or recordings. Skim the diff for pasted secrets. If anything suspicious turns up, stop and ask rather than guess.
+
+Stage explicit paths (`git add <path> ...`), never a blanket `git add -A`, so unrelated or ignored-by-intent files cannot slip in. Paths excluded via `.git/info/exclude` are excluded on purpose; leave them alone.
+
+## 3. Split into atomic commits
+
+One commit = one logical change that builds and passes tests on its own. If the working tree mixes concerns (feature + refactor + docs + tooling), propose an ordered split and commit each part separately; ask only if the grouping is genuinely ambiguous. Flag drive-by edits unrelated to the task and leave them out. On a first commit with everything untracked, group by area (e.g. agent/tooling config, shared docs, each app or package) instead of one giant commit.
+
+## 4. Verify
+
+Run checks proportional to the change, using the project's own commands (see AGENTS.md or the package manifest; run them from the workspace root):
+- Source changes: lint and tests.
+- Type, schema, build-config or dependency changes: also the build.
+- Docs, config or tooling only: skip.
+
+If a check fails, fix it or report it and do not commit. Never bypass with `--no-verify`: hooks and checks exist to protect the history.
+
+## 5. Write the message (Conventional Commits 1.0)
+
+```
+<type>(<scope>): <imperative summary>
+
+<body: why this change, constraints, trade-offs>
+
+<footers>
+```
+
+- **Type**: `feat`, `fix`, `refactor`, `perf`, `test`, `docs`, `build`, `ci`, `chore`, `style`, `revert`.
+- **Scope** (optional, lowercase): the area touched, e.g. a module or package name, `ui`, `docs`, `agent-config`, `deps`.
+- **Subject**: imperative mood ("add", not "added"), no trailing period, ideally ≤ 50 chars, hard limit 72. It must say what the change does, not "update stuff" or "fix bug".
+- **Body** (skip for trivial changes): wrap at 72, blank line after the subject. Explain motivation and non-obvious decisions; the diff already shows the *what*.
+- **Footers**: `BREAKING CHANGE: <what breaks and how to migrate>` when applicable, `Refs: <ticket>` for items from the project's ticket list, then the attribution trailer(s) your session instructions specify.
+
+## 6. Commit and confirm
+
+Commit with a heredoc so formatting survives: `git commit -F - <<'EOF' ... EOF`. If a hook fails, fix the cause and create a new commit; do not amend or skip it. Afterwards run `git show --stat HEAD` and `git status --short`.
+
+## 7. Report
+
+Give the hash, subject, files changed, what was verified, and anything intentionally left uncommitted. Do not push, amend published commits, reset, or change git config unless the user explicitly asks.
+
+## Examples
+
+```
+feat(search): add a filter to the results list
+
+The list showed every record. Add a filter so a reader can narrow it
+without leaving the page.
+
+Refs: features#search-filter
+```
+
+```
+fix(settings): keep the saved name when a draft is migrated
+
+The migration copied the draft over the saved name and dropped the last
+saved value.
+```
+
+```
+chore(agent-config): add agent-browser, chrome-devtools MCP and discipline rules
+```

package/templates/skills/orchestrate-workers/HC.md

@@ -0,0 +1,10 @@
+# `hc` quick reference
+
+Coding agents (Claude Code, Codex, cursor-agent) run in **herdr** terminal tabs. `hc` (herdr-core) lets one agent talk to another's pane from the shell.
+
+- `hc ls` — list terminals (address like `t2`, agent, cwd, status). Run it first: pane addresses change.
+- `hc read <t>` — print a pane's screen and history.
+- `hc send <t> <text>` — paste text and press enter. It prefixes a `<hc from=...>` header, so use it for agent prompts, not shell commands. To type a shell command: `hc keys <t> c o d e x enter`.
+- `hc wait <t>` — block until the agent stops working (never returns for cursor-agent; the skill's `watch.sh` covers that). Also: `hc interrupt`, `hc keys`, `hc put <t> <file>`.
+
+Notes: a Cursor pane may show as plain `zsh`; confirm the pane before sending. Do not launch agents with full-access flags (`codex exec -s danger-full-access`, `cursor-agent --force`); the permission classifier blocks that. Claude's `SendMessage` only reaches Claude sessions.