# tackle.tools

> tackle is the home for small workshop TUIs you run in your own terminal —
> your gear. It's one Go monorepo where each tool is an independent binary you
> install on its own. A .tools family member in spirit: local-first, runs on
> your machine, keeps state on your disk, never phones home. The name is a
> double meaning — your tackle is the gear you work with, and it's what you do
> to a task. Five tools ship today: proj, scratch, creel, sift, and imprint. Local-first and
> MIT, like the rest of the .tools family.

Site: https://tackle.tools
Source: https://github.com/subaud-tools/tackle

## What tackle is

- The home for small, sharp terminal tools — the ones you keep on the bench
  and reach for all day, distinct in spirit from the family's single-purpose
  products (a coordination bus, a review tool, a setup engine).
- One Go monorepo (`github.com/subaud-tools/tackle`) with one tool per `cmd/`
  directory; each ships as its own independent binary.
- Terminal-native TUIs built with Bubble Tea. No daemon, no browser, no
  account. Agent-aware where it helps.

## proj — the agent-aware tmux session picker

Page: https://tackle.tools/proj/

- The way IN to a work session: a Bubble Tea picker for the tmux sessions you
  actually work in.
- Lists live sessions with the coding agent running in each and its state
  (e.g. `claude·run`, `codex·idle`), resolved live.
- Surfaces muster attention: a session waiting on muster mail carries a ✉ flag
  in the list.
- Preview pane shows the highlighted session — working directory, windows, the
  agent's current activity.
- Understands one tmux server per project (the `proj-<name>` socket convention
  muster uses) and has a configurable sidebar.
- Starting new work, `Tab` cycles the agent and `Shift-Tab` opens a filterable
  list of that agent's models. Claude Code's menu is a built-in Anthropic list;
  pi's is discovered from `pi --list-models`, filtered to the providers named
  in `~/.config/proj/config.toml` under `[model_providers]`.

## scratch — the session-scoped scratchpad

Page: https://tackle.tools/scratch/

- A scratchpad TUI scoped to your SESSION, most-specific first: the coding-agent
  session, else the tmux session, else the working directory.
- Autosaves as you type; the file lives under your config dir
  (`~/.config/scratch/pads/`), never in the repo. `SCRATCH_DIR`/`SCRATCH_FILE`
  override the location.
- An agent can shell out to the same pad: `scratch append <text>`,
  `scratch print`, `scratch path` — one shared surface between you and the
  agent in the session.

## creel — masked secret capture into a local .env

Page: https://tackle.tools/creel/

- The safe way to hand a running agent an API key: creel prompts for the value
  in a masked field and writes it straight into a local `.env` file.
- The secret goes from your keyboard to the file; the agent that opened creel
  receives only a status token saying the key was written.
- Run it yourself (`creel NAME`), or let a harness drive it
  (`creel NAME --dest PATH --status-file F`) — as pi's `request_secret` tool
  does. Atomic `.env` upsert; the destination is confined to the working dir on
  the harness path.

## sift — audits of the instruction files your agents read

Page: https://tackle.tools/sift/

- Audits the instruction files coding agents read: each agent's global file
  (e.g. `~/.claude/CLAUDE.md`) and skills, and every instruction file (e.g. a
  repo's `AGENTS.md` or `CLAUDE.md`) in the repos under the directories you
  name, read at each repo's fetched default branch.
- Eight checks: size, load limit, duplicate, dead path, stale status, retired
  store, misplaced and secret. A certain finding must be fixed.
- An agent runs a round through the sift channel and skill: it writes one
  revised version of each file with findings, then you accept, edit or reject
  each file on a local review page and press Send.
- What you approve becomes one branch and pull request per repo (with `gh`);
  merging is yours. `sift clean` removes the branches once they are merged or
  closed.
- Setup: install, then `sift skills install` (again after each upgrade) and `sift init --root DIR`; `sift doctor` checks it. On macOS, `kempt apply -manifest cmd/sift/kempt.toml -packages sift` from a clone of the tackle repo also installs the Claude Code plugin and the pi channel. By hand, Claude Code takes `claude plugin marketplace add subaud-tools/plugins` and `claude plugin install sift@subaud-tools`. Turn on auto-update for the `subaud-tools` marketplace so the plugin stays current: in Claude Code, run `/plugin`, open the **Marketplaces** tab, select `subaud-tools` and choose **Enable auto-update**.

## imprint — an npm guide for coding agents

Page: https://tackle.tools/imprint/

- Gives a coding agent the npm steps a package owner takes, as channel tools:
  log in, show a package, publish a tarball, set its trusted publisher,
  deprecate it, and expect a CI release signed by a named repo.
- Opens each npm approval (and npm's login page) in your browser the moment
  npm asks, and sends each step's progress into the agent's session.
- Calls a step done only when the public registry shows it: a publish as live
  (npm takes 3 to 6 minutes), a deprecation as present, a CI release as signed
  by the right repo. A step npm already shows is skipped, so a retry asks for
  only what is left.
- The imprint skill holds the procedures: moving a trusted publisher, renaming
  a package, and proving each new trusted publisher with one CI release.
- Setup: install, then `imprint skills install` (again after each upgrade), and add it to your agent: in Claude Code, `claude plugin marketplace add subaud-tools/plugins` and `claude plugin install imprint@subaud-tools`; in pi, add `"imprint": {"command": "imprint", "args": ["channel"]}` under `channelServers` in `~/.pi/agent/channels.json`. On macOS, `kempt apply -manifest cmd/imprint/kempt.toml -packages imprint` from a clone of the tackle repo does both. Uses the npm on your machine. Turn on auto-update for the `subaud-tools` marketplace so the plugin stays current: in Claude Code, run `/plugin`, open the **Marketplaces** tab, select `subaud-tools` and choose **Enable auto-update**.

casebook has its own site, installer and llms.txt at https://casebook.tools.

## Install

- One command, checksum-verified, installs to `~/.local/bin`:
  `curl -fsSL https://tackle.tools/install.sh | sh` (all tools), or
  `… | sh -s proj scratch creel sift imprint cull` to pick.
- Re-run to upgrade; `<TOOL>_VERSION=X.Y.Z` pins a version.
- From source: `go install github.com/subaud-tools/tackle/cmd/<tool>@latest`
  (`proj`, `scratch`, `creel`, `sift`, `imprint`, `cull`).

## The family

- https://galley.tools — document review for agent-driven development
- https://muster.tools — local multi-agent coordination bus
- https://channels.tools — reach a running pi session through its channels
- https://hail.tools — reach a running pi session from your phone (coming soon)
- https://kempt.tools — declarative machine setup you can read before you run
- https://casebook.tools — a decision for every repo, PR, issue, branch and worktree
- https://muda.tools — find and fix delivery waste in GitHub Actions
- https://subaud.tools — the family landing page