claude-jacked - multi-account manager and skills suite for Claude Code

When you hit a Claude Code usage limit, jacked shows which account has headroom and helps you move deliberately instead of guessing which credentials a session is using. Run every Claude and Codex account you own as one fleet, watch each account's 5-hour, 7-day, and per-model usage live, and get an auto-swap recommendation before a limit stops you. The whole fleet stays one click away in a macOS menu-bar app, or a system-tray app on Windows and Linux.

It is also a skills manager for Claude Code: one jacked install deploys 20 curated slash commands, 28 skills, and 10 review agents into ~/.claude, mirrors them into Codex when Codex is installed, and keeps them updated from a web dashboard.

What you get: multi-account Claude Code, live usage tracking, and a skills suite

• Run multiple Claude accounts without losing account truth. Add every account you own, watch each account's 5-hour, 7-day, and per-model usage live, and let auto-swap recommend a fresh account before you hit a limit. Credential changes report what was actually verified, and session cards distinguish where a session started, what configuration was later observed, and whether the provider runtime is still unverified. Works for Codex accounts too, side by side with Claude.
• A menu-bar app that actually earns its pixels. A live pill shows usage for the account jacked can currently resolve next to the clock (18%·4%, tinted green/yellow/red). Left-click drops the whole fleet down in a compact panel: every account, every org, per-model caps, reset times, and the current credential state. Right-click for actions, or pin the panel to your screen edge. It refreshes within about a second of any account switch or usage change, and it tells you when a new jacked version ships: a badge on the icon, a notification banner, and a one-click update.
• A curated skills suite, one command to install. jacked install puts 20 battle-tested slash commands, 28 skills, and 10 review agents into Claude Code (/dcr recursive multi-lens review, /qa//ux browser testing, /release, /whats-next roadmap advisor, /lockdown supply-chain audit, and more; skills are slash-invocable too, so all 48 answer to a /name), plus design-engineering skills for UI animation and polish adapted with credit from Emil Kowalski's skills and a website-cloning skill adapted with credit from JCodesMore's ai-website-cloner-template. When Codex is installed too, the same pass deploys the suite into Codex's native formats: skills into ~/.agents/skills, commands as both prompts and command-derived skills, the behavioral rules (Codex-adapted) into ~/.codex/AGENTS.md, the 10 review agents as Codex TOML custom agents, the chrome-devtools MCP server, and a $qa suggestion hook, with a few Claude-only helpers held back and everything tracked in a Codex manifest so jacked uninstall reverses it. Upgrades diff cleanly: added/changed/removed, never touching your own files. On top of the bundled suite, jacked install also installs curated third-party skill packs live from their upstream repos (a 28-skill marketing pack and a design-extras pack, on by default), opt out with --no-packs or jacked packs disable.
• Manage everything from a web dashboard. Accounts, usage analytics, feature toggles, appearance themes, swap history, logs, all from your browser. No config files, no terminal commands.
• Permission hygiene built in. jacked permissions audit finds (and can prune) dangerously broad Bash wildcards in your Claude Code permission allowlists, and the dashboard's Permissions panel manages allow rules with project vs global scope.

Quick start: install jacked and add your Claude accounts

Option 1: Let Claude Install It

Paste this into Claude Code and it handles everything:

Install claude-jacked for me:

1. First check if uv and jacked are already installed (if uv is missing: curl -LsSf https://astral.sh/uv/install.sh | sh)
2. Install: uv tool install claude-jacked && jacked install --force
3. Verify with: jacked --help
4. Confirm the service URL with: jacked service status
5. Open the reported dashboard URL in my browser
6. Walk me through adding my Claude accounts from the Accounts page

Option 2: Manual Install

Run once from anywhere. This installs the shared skills, hooks, dashboard, and tray integration under ~/.claude/:

uv tool install claude-jacked   # tray icon + background service included by default
jacked install --force          # deploys skills/commands/agents/hooks AND starts the tray
jacked service status           # prints the running dashboard URL

Open the URL printed by jacked service status, or choose Open Dashboard from the tray. Use jacked webux only when you want a foreground dashboard instead of the background service; both cannot own the same port at once.

The tray is on by default. A bare uv tool install claude-jacked now ships the tray (no [tray] extra needed), and jacked install registers login-autostart and starts it. Don't want the icon (or on a headless box)? jacked install --force --no-tray. You MUST run jacked install - uv tool/pip install only drop the package on disk; running jacked before that prints a loud banner reminding you.

Don't have uv? Install it first: curl -LsSf https://astral.sh/uv/install.sh | sh (Mac/Linux) or powershell -c "irm https://astral.sh/uv/install.ps1 | iex" (Windows)

Option 3: Install as a Plugin (Teams)

Add to your team's Claude Code environment - no Python install needed:

/plugin marketplace add jackneil/claude-jacked
/plugin install jacked@jacked-marketplace

Everything is namespaced under jacked:, so a command is /jacked:pr and a skill is /jacked:dcr. Includes all 20 commands, 28 skills, and 10 agents. Does not include the Python-powered features (dashboard, account management, tray) - use Option 1 or 2 for those.

The background service + system tray icon ship by DEFAULT (auto-start on login) - jacked install already started them. Opt out of the icon: jacked install --force --no-tray. The legacy [search]/[security]/[tray]/[all] extras still resolve as empty aliases, so old install commands don't error - the features they gated were retired in 0.70.0 (Qdrant session search) or folded into core (tray).

Your dashboard: accounts, usage analytics, and feature toggles

The web dashboard ships with every install. Open it from the tray, or run jacked service status and browse to the reported URL. To run the dashboard in the foreground without the tray service, stop that service first and use jacked webux.

Toggle Features On and Off

Enable or disable any of the 10 built-in code reviewers, 20 slash commands, and 28 skills with one click. Each card shows what it does so you know what you're turning on.

Track Everything

Token usage and estimated cost per session, agent activity, hook health, and command frequency, all at a glance. The Activity view below shows which review agents ran and whether every hook is executing cleanly.

Table of Contents

• What's Included
• Web Dashboard
• Background Service and Tray Icon
• Upgrading
• Built-in Reviewers and Commands
• Sound Notifications
• FAQ
• Uninstall / Troubleshooting
• Version History
• Advanced / Technical Reference

What's Included

Base (uv tool install claude-jacked)

Web Dashboard

jacked webux                    # Foreground dashboard at localhost:8321
jacked webux --port 9000        # Custom port
jacked webux --no-browser       # Start server without opening browser

The dashboard is a local web app that runs on your machine. All data stays in ~/.claude/jacked.db - nothing is sent anywhere.

5 pages: Accounts, Installations, Settings (tabbed: Agents / Commands / Features / Plugins / Claude Code / Appearance / Advanced), Logs, Analytics.

Remote Access (Tailscale)

By default the dashboard binds 127.0.0.1 and is reachable only from the machine it runs on. To reach it from other machines, flip it on in the GUI: Settings > Advanced > Remote access.

• Tailscale only (recommended): binds loopback plus this machine's Tailscale address (100.x). Reachable from your tailnet, invisible to whatever LAN or coffee-shop Wi-Fi the machine is on. If Tailscale isn't running at startup, jacked falls back to loopback only and says so in the card's status line; it re-detects on every restart.
• All interfaces: binds 0.0.0.0. Anyone on any network the machine joins can reach the dashboard. You'll be asked to confirm you understand before this applies.

Applying a change restarts the dashboard in place (a few seconds; the page reconnects itself). The setting lives in ~/.claude/jacked.db and is the single source of truth: it survives reboots, upgrades, and service restarts. The card's status line always shows the addresses the server is actually listening on, so what you see is what is live.

Once enabled, browse to http://<machine>:8321 using the MagicDNS short name, the full <machine>.<tailnet>.ts.net name, or the Tailscale IP.

Account authorization works from a remote browser. When you open the dashboard from a different machine, the Add Account, Re-auth, and CC-token flows show an authorization link instead of opening a browser on the server. Click the link and approve in your own browser. Claude then shows a code. Copy the code and paste it into the dashboard to finish.

Prefer the CLI? These write the same setting (no more baked hosts in autostart files):

jacked service restart --host 0.0.0.0     # sets Remote access: all interfaces, then restarts
jacked service restart --host <100.x IP>  # sets Remote access: Tailscale only, then restarts
jacked service restart --host 127.0.0.1   # turns Remote access off, then restarts

A one-shot override for a foreground dashboard only (never persisted): jacked webux --host <addr>.

The dashboard has no authentication layer, so restrict who can reach it at the network layer. A Tailscale ACL scoped to the port does exactly that:

{ "action": "accept", "src": ["your-laptop", "your-phone"], "dst": ["your-server:8321"] }

A network bind is hardened server-side: CORS is never wildcarded (the frontend is same-origin by construction), WebSocket handshakes enforce same-origin, cross-site state-changing requests are rejected by Origin check, and untrusted Host headers are refused (DNS-rebinding guard). Two escape hatches exist for unusual manual or foreground setups, both comma-separated environment variables set directly on that process. Native managed definitions intentionally do not inherit arbitrary shell variables:

• JACKED_ALLOWED_ORIGINS: extra exact origins (scheme://host[:port]) allowed cross-origin API/WebSocket access. Needed behind a reverse proxy that rewrites Host to the loopback upstream (symptom: page loads but every write and the live WebSocket fail with 403; tailscale serve preserves Host and needs nothing).
• JACKED_ALLOWED_HOSTS: extra hostnames accepted in the Host header, e.g. a custom DNS name pointing at the machine.

Prefer not to rebind at all? tailscale serve --bg 8321 proxies the loopback-bound dashboard to your tailnet over HTTPS with no jacked configuration changes.

Account switching, auto-swap, and session truth

Use Account requests a change to the default Claude credential stores. The result is evidence-qualified: the dashboard says whether the target was committed, merely observed without a complete writer fence, needs interaction, or is unsupported. It never turns a database selection into a false claim that running sessions changed. Credential mutation is local-only, so a remotely opened dashboard can manage and inspect accounts but cannot switch credentials.

Current support is deliberately conservative. The exact Claude Code 2.1.259 macOS arm64 build can report observed_target_unfenced: the requested credentials were read back, but another writer cannot be ruled out, so existing sessions remain unverified and a restart is recommended. An unknown executable, build, platform, architecture, or configuration mode fails closed instead of guessing how that Claude Code version stores credentials.

For a specific account, launch Claude Code through jacked:

jacked claude 2                    # account ID
jacked claude jack@example.com     # full email
jacked claude udifi --resume       # unique email substring + Claude arguments

The launcher prepares a per-account CLAUDE_CONFIG_DIR and passes every remaining argument through to Claude Code. That records the intended scoped target, but it does not claim the provider runtime used that identity until an exact-build capability can prove it. Session cards therefore show Started as, Observed configuration, Pending next activity, and Runtime unverified separately. A default-credential change marks known global sessions pending; the next hook activity refreshes configuration evidence, not proof of which identity served the provider request.

Auto-swap still evaluates account headroom and records a recommendation. It performs the credential mutation only when a certified cooperative transaction engine and writer fence are installed for the exact runtime. Without that capability, it stays recommendation-only.

Background Service and Tray Icon

Here's the deal: if you don't want to remember to run jacked webux every time, run it as a background service instead. On macOS you get a live usage pill in the menu bar with the whole fleet one click away; on Windows and Linux you get a "J" in the system tray that stays out of your way until you need it.

Install

uv tool install claude-jacked --force   # pystray + Pillow ship in the base package
jacked install --force                  # wires up hooks AND starts the tray (autostart on login)

jacked install already registers login-autostart and starts the tray - no separate jacked service install/start needed. pystray and Pillow are core dependencies now, so the icon "just works" out of the base package. Don't want it? jacked install --force --no-tray.

What You Get (macOS menu bar)

• A live usage pill, always visible. The menu-bar item is a colored "J" plus the resolved account's usage as 5h%·7d% (e.g. 18%·4%). The J tints green, yellow, or red on the worse of the two windows, so a glance at the clock tells you whether you're about to hit a limit. A small dot marks the corner when the resolved account is a Codex account.
• Left-click: the fleet dropdown. A compact panel (the screenshot up top) drops down with every account you've added: 5h and 7d bars with reset times, per-model caps (your Fable or Codex model usage inline), plan badges, multi-org accounts grouped under one login, an active badge with a live countdown to the next usage refresh, and a refresh-all button. It's pre-warmed, so it opens instantly.
• Pin it as a side panel. "Toggle Side Panel" docks the same panel to the right edge of your screen, floating above other windows and on every Space, for a permanent fleet view while you work.
• Right-click: the actions menu. Open Usage Dropdown, Toggle Side Panel, Open Dashboard, Add Account, an Auto-swap toggle, Start on Login, Restart, Quit, the version line, "Last checked", and Check for updates... to force a fresh PyPI poll on demand.
• It never goes stale. The pill and panel update within about one second of any usage refresh, credential-state change, or Codex swap (an in-process change counter, no polling lag), with a 30-second heartbeat backstop and a 10-minute background refresh across the whole fleet.
• Update notifications you'll actually see. When a new version ships: a blue badge appears on the J icon, a macOS notification banner fires, and the version line in the menu flips to a clickable v{current} -> v{latest} (update). One click runs the full upgrade (uv tool install --force + jacked install --force + service restart) in a detached helper that survives its own binary being replaced, with a live progress page in your browser that reconnects on its own while the service restarts.

On Windows and Linux

• System tray icon ("J", colored by service state) with the same right-click menu essentials: Open Dashboard, Restart, Stop, Start on Login, version line, and Check for updates.
• The full update flow: the icon badge, native tray notifications, the clickable one-click update, and the browser progress page all work the same as on macOS. The usage pill, dropdown panel, and side panel are macOS-only today.

Service behavior

• Exact, per-user auto-start - jacked service install generates an owned launchd definition on macOS, a systemd user unit on Linux, or a Task Scheduler definition on Windows from the current package version and interpreter.
• One managed background API owner per OS user - a lifetime lease makes competing managed starters lose cleanly. Installation can hand off a verified manual v2 instance before activating the native supervisor, so an upgrade does not create two owners.
• Authenticated lifecycle control - status, stop, and restart discover the running instance through a private manifest, lifetime lease, and per-user control channel, not by trusting whichever process occupies a port. They refuse PID-only process control when ownership cannot be proved.
• Safe port collisions - the owned service uses port 8321 when available. If that port belongs to an ambiguous or foreign process, jacked starts on a dynamic quarantine port for the configured bind and jacked service status reports the actual dashboard URL.
• Secret-negative startup - native service definitions start isolated Python with a small reviewed environment. Tokens and unrelated shell environment variables are not inherited into the long-lived service.
• Crash recovery, not nag-ware - each native supervisor restarts failed runs but respects a clean user stop. On launchd this is KeepAlive scoped to SuccessfulExit=false; systemd and Task Scheduler carry matching failure-only restart policies.
• Non-destructive recovery - jacked service recover reconciles drift only when the native definition is provably jacked-owned. It refuses legacy or foreign same-name artifacts, prints the exact path that needs operator review, and never adopts, deletes, or signals them automatically.
• CLI equivalent - jacked upgrade does the same three-step upgrade from the terminal. No more remembering to run uv tool install, then jacked install, then restart the service separately.
• Recovery file - if the auto-update fails, ~/.claude/jacked-update-failed.txt explains what happened and how to recover manually. The tray warns you on the next startup so you don't miss it.

Commands

jacked service install     # configure auto-start (launchd / systemd user / Task Scheduler)
jacked service start       # start the service with tray icon (foreground - blocks)
jacked service stop        # stop the running service
jacked service restart     # stop + detached start (returns immediately)
jacked service restart --foreground   # same but runs in foreground like service start
jacked service status      # show evidence-qualified state, build, protocol, port, autostart
jacked service recover     # safely reconcile a provably owned native definition

Troubleshooting

If the tray icon disappears, will not come back, or port 8321 is already occupied, start with evidence instead of a PID file:

jacked service status      # reports running, quarantined, stopped, or indeterminate
jacked service restart     # uses the authenticated control channel when ownership is proven
jacked service recover     # reconcile owned drift without PID- or port-based control

If status says quarantined, use the dashboard URL it prints. Another process owns 8321, and jacked deliberately leaves that process alone. If status says ownership indeterminate, run jacked service recover. Recovery refuses a legacy or foreign supervisor artifact and prints its exact path; stop that service from its own tray menu, inspect and move the artifact to a backup path, then retry recovery. Do not kill a PID copied from the legacy diagnostic file at ~/.claude/jacked-service.pid.

Common issues:

• Tray icon never appears after install - the tray ships by default now, so the usual causes are: (a) you passed jacked install --no-tray, (b) you're on a headless box (no DISPLAY/Wayland) where the icon is skipped on purpose, or (c) the service is not running. Run jacked service status; use the reported dashboard URL if the service is quarantined, or run jacked service start if it is stopped.
• Tray shows a wrong version after an upgrade - run jacked service status to compare the owned service build with the installed version. If ownership is proven, jacked service restart performs an authenticated handoff. If ownership is indeterminate, use jacked service recover; do not signal a PID manually.
• "Port 8321 in use" - run jacked service status. A v2 service quarantines itself onto a discoverable dynamic port instead of killing the listener, so use the dashboard URL status prints.
• Auto-update ran but the tray never came back - run jacked service status, then jacked service recover to reconcile a provably owned native definition. Recovery stops with exact-path guidance if it finds a legacy or foreign artifact.
• Claude Code keeps asking me to log in - jacked was rotating the active account's CC refresh token out from under Claude Code. Fixed in 0.41.2+. Update and the issue goes away. Architecture doc at docs/architecture/oauth-and-credential-flows.md §7.1-7.3 explains the full mechanism.
• Auto-update failed - read ~/.claude/jacked-update-failed.txt and the log at ~/.claude/jacked-update.log. The recovery file lists the exact commands to finish the upgrade manually.

Verify what's actually running:

# What endpoint and version is the live tray reporting?
jacked service status
curl -s http://127.0.0.1:8321/api/version   # use the Port value reported above
# {"current":"0.99.1","latest":"0.99.1","outdated":false,...}

If current is older than the version your uv tool list shows, the running tray predates the install. Use the authenticated restart or recovery flow above.

Installing from scratch

We use uv for installation - it's a standalone tool from Astral that installs and manages Python CLI apps in isolated venvs. Much faster than pip, handles Python interpreter management, and keeps claude-jacked from conflicting with anything else on your system. Follow the steps for your OS.

macOS

# 1. Install uv (skip if you already have it)
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. Reload your shell so `uv` is on PATH. Either restart your terminal or:
source ~/.zshrc   # or ~/.bashrc

# 3. Verify
uv --version

# 4. Install jacked (tray icon ships by default)
uv tool install claude-jacked

# 5. Wire up Claude Code hooks + the launchd auto-start + tray
jacked install

Notes:

• uv's installer adds ~/.local/bin to your shell rc automatically. If jacked --version says "command not found" after step 5, run uv tool update-shell && source ~/.zshrc or open a fresh terminal.
• The owned launchd definition lives at ~/Library/LaunchAgents/ai.hank.jacked.plist. If it conflicts with a legacy or foreign definition, jacked service recover refuses to replace it and prints that exact path for review.

Linux

# 1. Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. Reload shell
source ~/.bashrc   # or ~/.zshrc / ~/.profile

# 3. Verify
uv --version

# 4. Install jacked (tray icon ships by default)
uv tool install claude-jacked

# 5. Wire up Claude Code hooks + the systemd user service + tray
jacked install

Notes:

• Requires a system tray provider (most desktop environments ship one - GNOME may need the AppIndicator extension; KDE/Cinnamon/XFCE work out of the box). On a headless box, run jacked service start, then use jacked service status for the actual dashboard URL and ~/.claude/jacked-service.log for logs.
• jacked service install reconciles and enables a per-user systemd unit. It never needs a root system service.

Windows

# 1. Install uv (standalone installer, no Python prerequisite)
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

# 2. Close and reopen your terminal so `uv` is on PATH.
#    The installer added %USERPROFILE%\.local\bin to User PATH.

# 3. Verify
uv --version

# 4. Install jacked (tray icon ships by default)
uv tool install claude-jacked

# 5. Wire up Claude Code hooks + Task Scheduler auto-start + tray
jacked install

Notes:

• After step 4, jacked.exe lives at %USERPROFILE%\.local\bin\jacked.exe. uv's installer adds that dir to PATH - if jacked --version fails, open a new terminal (PATH changes don't propagate into open ones).
• jacked service install registers a current-user, least-privilege Task Scheduler definition backed by a private, hash-verified PowerShell launcher.
• PowerShell execution policy warning: if irm | iex is blocked, run Set-ExecutionPolicy -Scope CurrentUser RemoteSigned first, or download and run the installer script manually from astral.sh/uv/install.ps1.
• If the tray icon does not appear, run jacked service status first. Use the dashboard URL it reports when the service is running or quarantined, and check %USERPROFILE%\.claude\jacked-service.log for details.

After install (all platforms)

Run jacked service status for the dashboard's actual URL. It normally uses http://localhost:8321; a safe quarantine start uses a reported dynamic loopback port instead. The tray icon's right-click menu has Open Dashboard, Restart, Stop, Start on Login, version + "Check for updates...", and the clickable "Update to vX.Y.Z ->" item when a newer version hits PyPI.

Upgrading later is one command: jacked upgrade (from the terminal) or click the Update line in the tray menu. Both auto-detect that you installed via uv and re-use it. Don't have uv anymore? Reinstall it first: same curl/powershell commands as step 1.

Requirements: Python 3.10+ (uv will fetch one for you if your system doesn't have a compatible version - you don't need to install Python separately).

Upgrading

jacked upgrade

That's it. One command. Works on macOS, Linux, and Windows. Does all three things uv tool install --force alone doesn't do:

1. uv tool install claude-jacked --force - new package on disk
2. jacked install --force - migrate settings.json hooks to the shim form (jacked _hook <name>) so they survive Python version bumps
3. jacked service restart - reload the running service with the new code (only if a service is running)

Why you need all three: uv tool install --force just drops the new package on disk. The service you already have running is still executing the old version in memory, and your settings.json may still have hook paths that point at the old site-packages location (broken if uv upgraded Python under you).

Options

• jacked upgrade --skip-service - just swap the package and migrate settings, don't restart the running service

Cross-platform notes

• macOS/Linux: runs inline. Your terminal shows live output from each step.
• Windows: spawns a detached cmd.exe helper and exits immediately. Windows can't overwrite a running .exe, so this process has to step out of the way before uv tool install replaces jacked.exe. The helper waits for this process to exit, then runs the three steps with output appended to ~/.claude/jacked-update.log. You can type %USERPROFILE%\.claude\jacked-update.log to follow along.

Tray upgrades

If you're running the background service, you can also click Update to vX.Y.Z -> in the tray menu when a newer version is available on PyPI. Same three-step sequence, fully detached - survives its own binary being replaced mid-update.

What changed in this update

jacked install and jacked upgrade print a concise change-summary instead of a static banner: the version before → after, plus exactly which skills, commands, agents, lenses, and templates were added / changed / removed (and a count of everything unchanged). It's backed by a manifest (~/.claude/jacked-manifest.json) recording what jacked installed, so an upgrade can also prune artifacts it no longer ships - without ever touching your own files. The same summary shows up in the dashboard as a one-shot panel after an upgrade. Run jacked install --json for the machine-readable diff.

/recover - rebuild a crashed session

Opened Claude in a folder whose last session crashed mid-work and you don't know the session ID? Run /recover. It finds the most-recently-active prior session for the current folder from its on-disk transcript, shows you the pick to confirm, then injects a budgeted working-state digest (last instruction, todos, recent actions, files touched) so you continue right where it died - and prints claude --resume <id> for a full native continuation. Works on a bare install.

It recommends the newest session with real substance - a near-empty newest session is skipped (but still offered as an alternate). And if the crashed session was actively driving a /goal or /loop (which can't be auto-resumed), the digest surfaces that exact command verbatim so you can copy-paste it back into Claude Code to restart it.

/whats-next ambition: safe by default, /bhag to build it all

/whats-next is the everyday, safe-by-default roadmap command: it picks the highest-leverage work and forges a /goal brief that lands on a feature branch and opens a PR for review - it never merges to main itself.

When a product is pre-production and you want it driven to completion autonomously, run /bhag (Big Hairy Audacious Goal). It runs the coverage matrix at full breadth and forges a long-running /goal brief that loops cell-by-cell - implement → verify → PR → merge to main → next - until the product is built out. Auto-merge is double-gated: it only happens when the repo's declared Lifecycle is Greenfield/Alpha and you explicitly authorize it in-session (and only after CI is green); on anything resembling a live product it refuses and degrades to safe staged PRs. /bhag is a deliberately-typed command (never auto-triggered), because auto-merging to main in a loop is the most powerful thing jacked can do.

Already know what to build? Run /goal-maker - it skips the deciding and packages the work already in front of you (this conversation, a spec, a plan, an in-flight build) into one hardcore, overnight-sized /goal brief: full scope, TDD + tests-green, UI/UX + front-end-polish gates, evidence-based DONE, and a Next: line so a later /whats-next picks up. It defaults to opening a PR; pass merge (/goal-maker merge) to auto-merge each milestone - always gated on green CI, never a red build, and with the gh pr checks output pasted so the run is verifiable. Like /bhag it's deliberately typed (never auto-triggered) so auto-merge can't be reached by accident. The trio: /whats-next decides, /goal-maker packages what you've decided, /bhag drives the whole matrix autonomously.

Built-in Reviewers and Commands

Quick Commands

Type these directly in Claude Code:

Smart Reviewers

These work automatically when Claude thinks they'd help, or you can ask for them:

Example: After building a new feature:

Use the double-check reviewer to review what we just built

Skills

Alongside the commands, jacked install ships 28 skills: knowledge packs and engines Claude invokes by name or picks up automatically when the task fits. Every skill answers to /name; these ten used to ship as commands and keep their familiar slash workflow:

The full set, grouped:

The four design-engineering skills are adapted from Emil Kowalski's excellent emilkowalski/skills (MIT), built on his years of design-engineering work and his course at animations.dev. They teach Claude the craft details agents usually get wrong: easing choice, spring parameters, interruptibility, prefers-reduced-motion, and when the right animation is no animation. jacked's /dcr frontend reviewer automatically pulls in review-animations when a diff touches motion code.

Skill Packs (installed by default, opt out anytime)

Beyond the bundled suite, jacked installs curated collections of third-party skills directly from their upstream repos. Nothing is vendored: install and updates run through the vercel-labs skills CLI (npx skills, requires Node 18+), so the upstream repo stays the source of truth and every jacked install refreshes them. If Node is not present, packs are skipped with a note and the rest of the install is unaffected.

The default packs install with a plain jacked install. To opt out:

jacked install --no-packs          # skip packs entirely for this install
jacked packs disable marketing     # durably remove a pack (it won't return on the next install)
jacked packs list                  # see packs, on/off/default status, and install counts
jacked packs enable design-extras  # re-enable a disabled pack, or add a non-default one
jacked packs update                # refresh enabled packs from upstream

Packs can also be toggled from the dashboard (Settings > Features > Skill Packs). Skills install for Codex too when it is present. Removal is source-checked against the skills CLI lockfile, so a same-named skill you installed yourself from another repo is never touched, and a skill directory you already own is never overwritten. Because packs are on by default, a plain jacked install pulls third-party content from those repos' main branch at install time; if that trust boundary matters for your environment, run jacked install --no-packs or disable the packs you do not want. A disable is durable: a pack you turn off stays off across future installs.

DCR Review Engine (run reviews on Codex, opt in)

/dcr spawns several parallel review agents per wave. By default they run on Claude and spend your Anthropic plan. If you have the OpenAI Codex CLI installed and signed in, you can route the volume reviewers to a Codex model instead and pay for review fan-out with your OpenAI subscription:

jacked dcr engine set codex --model gpt-5.6-luna --effort xhigh
jacked dcr engine          # show the current config and live Codex readiness
jacked dcr engine clear    # back to Claude (the default)

Or use the dashboard: Settings > Features > Review Engine.

What stays the same: the parent Claude session still selects the lenses, validates every finding against the real code before any fix, applies the fixes, and issues the verdict. Security and design reviews stay on Claude by default (the keep_on_claude list; you can change it with the CLI). What changes: the read-only reviewer briefs execute as codex exec jobs in a read-only sandbox, and findings come back as schema-validated JSON. With a fast, low-cost model like GPT-5.6 Luna at xhigh effort, a full review wave costs a fraction of the Claude equivalent.

Safe by default: no config means pure Claude. Codex missing, signed out, a corrupt config file, or a failed or hung Codex job all fall back to Claude automatically. A review never blocks on the engine, and no review lens is silently dropped.

Memory Vault (cross-repo memory, opt in)

Claude forgets everything between sessions, and worse, everything it learned in one repo is invisible in the next. Memory Vault fixes both. It's a git-backed Markdown vault at ~/jacked-vault that captures durable decisions, conventions, and progress as you work, then feeds the relevant slice back into new sessions. The notes are plain Markdown with [[wikilinks]], so the vault opens in Obsidian as a viewer, but there is no database, no embeddings, and no MCP server: recall is grep plus a hand-maintained index, and the vault is its own git repo you can push to a remote or keep entirely local. It leaves Claude Code's native auto-memory completely untouched.

Turn it on from the dashboard (Settings > Features > Memory Vault) or from the CLI:

jacked memory init                 # scan your repos, suggest groups, install capture + recall hooks
jacked memory status               # vault health: groups, note counts, last capture, drift
jacked memory add                  # write a typed note (decision/convention/vision/reference/progress)
jacked memory search "auth flow"   # grep-tiered lookup: hot slice -> index -> notes
jacked memory rollup               # deterministic episodic rollup (today -> recent -> archive)
jacked memory migrate              # import existing .remember/ history (see below)

Capture is event-driven and quiet. A SessionEnd hook runs one local triage pass over the transcript; it writes an episodic entry every time, but a durable semantic note only when it finds a real decision, accomplishment, or convention, so most sessions write nothing lasting. Landing a branch fires the same instinct: a post-merge git hook on main/master distills the merge (branch, PR title and body, changed files) into a candidate note. Everything is processed locally, transcripts never leave the machine, and every hook fails open (exit 0 on any error) so memory can never block or slow a session.

Recall is budgeted. A SessionStart hook injects a group-scoped brief hard-capped at 1,500 tokens: the current progress slice, an index excerpt, the top-linked decisions, and the last episodic entry for the repo you are in, ending with an explicit pointer to the vault paths worth reading. Deeper recall is on-demand file reads against real paths, using the tools Claude already has.

A librarian keeps it honest. The memory-librarian skill dedupes notes, reconciles contradictions (newest wins, with a trail), archives stale entries, validates frontmatter, and re-syncs the index. It is nudged at SessionStart when the drift counter trips, or you can run it by hand.

Migration is safe by construction. jacked memory migrate imports every .remember/ directory under your configured roots into the vault, flags core memories as semantic candidates, and verifies imported file and entry counts against the source, failing loud on any mismatch. It never modifies or deletes the source .remember/ dirs. Retiring the third-party remember plugin happens only after migration verifies, and only after you confirm a printed summary of exactly what changes.

Statusline (session status at a glance, on by default)

jacked install registers a status line that Claude Code shows at the bottom of every session:

Fable 5 [xhigh] | ctx 63% (633k/1.0M) | 5h 7%->14:00 | 7d 88%->Sat 02:37 | me@co.com · MyOrg · Max 5x

Model and effort, context-window pressure with real token counts, both rate-limit windows with their reset times, and the latest evidence-qualified account state. A fresh global resolved snapshot can show the observed email. A scoped launch shows the desired account with runtime unknown unless its exact launch nonce, credential revision, and evidence binding are certified. Stale, conflicting, missing, or unusable evidence also stays visibly unresolved. Percentages are color-coded (green, then yellow at 60%, red at 85%). The renderer is a small stdlib-only Python module, registered with the absolute path of jacked's own interpreter, so it works the same on macOS, Linux, and Windows with no shell, jq, or PATH dependencies.

The install is safe by design. If you already have a statusline, jacked install keeps it and tells you how to adopt jacked's. An explicit enable saves your previous statusline and restores it when you disable or uninstall. An explicit disable is durable: the next jacked install does not turn the statusline back on.

jacked install --no-statusline     # skip the statusline for this install
jacked statusline enable           # adopt jacked's statusline (saves any existing one)
jacked statusline disable          # remove it and restore a saved one, if any
jacked statusline status           # registration state and the active command

The dashboard toggle lives at Settings > Features > Statusline.

QA Browser Testing

The /qa command runs browser-based QA on UI changes from the current session. It detects modified UI files (JS, CSS, HTML, Vue, Svelte, etc.), opens the app in a browser, and runs visual checks, interactive tests, and console error scans. Auto-suggested via a Stop hook when UI files are modified. Requires Playwright MCP or Claude-in-Chrome.

Asana in /whats-next

When Asana is reachable, /whats-next blends your assigned tasks into the same coverage-led recommendation as GitHub issues and code TODOs. Run /jacked-setup whats-next once per repo to probe for access (an Asana MCP plugin, a local asana CLI, or ASANA_PERSONAL_ACCESS_TOKEN) and write a ## Asana Integration block into the standalone command. Tasks that touch the current repo - by GitHub URL, repo basename, file/module mention, or project-name resemblance - are weighed alongside the rest, with priority and due-date read as demand/cost-of-delay signals. Asana origin appears on the Evidence line; it grants no priority bonus, and if Asana isn't configured the step is skipped silently.

Sound Notifications

Get audio alerts so you don't have to watch the terminal:

jacked install --force --sounds

• Notification sound - Plays when Claude needs your input
• Completion sound - Plays when Claude finishes a task

Works on Windows, Mac, and Linux. To remove: jacked uninstall --sounds

FAQ

How do I run multiple Claude Code accounts?

Install jacked, then add each account from the dashboard's Accounts page or let it walk you through the OAuth flow. Every account you own becomes part of one fleet. Use jacked claude <id-or-email> when you want a specific account target; the session remains runtime-unverified until exact-build evidence can certify which identity served it.

What happens when I hit my Claude Code usage limit?

Jacked identifies an eligible account that still has headroom and records an auto-swap recommendation. Automatic credential mutation happens only when the exact runtime has a certified cooperative transaction engine and writer fence. Otherwise jacked leaves credentials unchanged and tells you which account to choose.

Can jacked switch Claude accounts automatically?

Only on a runtime with a certified cooperative credential capability. Auto-swap always watches the 5-hour and 7-day headroom, but current unsupported or unfenced builds stay recommendation-only. Manual Use Account requests are local-only and return the exact outcome instead of claiming success from a database setting.

How do I check how much Claude usage I have left?

Three places: the statusline inside every Claude Code session, the tray or menu-bar pill next to your clock, and the dashboard's Accounts page. All of them show the 5-hour window, the 7-day window, per-model caps, and reset times.

Does jacked work with Codex?

Yes. Codex accounts sit side by side with Claude accounts in the same pool. When Codex is installed, jacked install also deploys the suite into Codex's native formats (~/.agents/skills, ~/.codex/AGENTS.md, Codex custom-agent TOMLs).

Does the tray icon work on Windows and Linux, or only macOS?

All three. macOS gets a native menu-bar agent; Windows and Linux get a system-tray icon through pystray. The statusline is cross-platform too, with no bash, jq, or PATH dependency.

Can I open the dashboard from another machine?

Yes, over Tailscale. Remote account authorization works too: the dashboard shows an authorization link instead of trying to open a browser on the server, and you paste back the code Claude gives you.

How do I install the slash commands, skills, and review agents?

uv tool install claude-jacked then jacked install. That deploys 20 slash commands, 28 skills, and 10 review agents into ~/.claude. Skills are slash-invocable too, so /dcr, /qa, /lockdown and the rest work exactly like the commands do. Teams can install it as a Claude Code plugin instead, with no Python required.

Will jacked overwrite my own Claude Code settings?

No. Upgrades diff cleanly (added, changed, removed) and never touch files you wrote. If you already have a statusline, jacked keeps yours and tells you how to adopt its own. A colliding skill directory you own is preserved rather than clobbered.

How do I uninstall jacked?

jacked uninstall && uv tool uninstall claude-jacked

Your database at ~/.claude/jacked.db stays intact, so reinstalling later keeps your accounts and history.

Uninstall / Troubleshooting

Uninstall

jacked uninstall && uv tool uninstall claude-jacked

Your local database (~/.claude/jacked.db) stays intact - reinstall anytime without losing accounts or history.

Common Issues

"jacked: command not found" - Run uv tool update-shell and restart your terminal.

Windows errors - Claude Code on Windows uses Git Bash, which can have path issues. Ask Claude: Help me fix jacked path issues on Windows

Version History

Advanced / Technical Reference

# Setup
jacked install --force             # Install skills, agents, commands, rules, tray
jacked install --force --sounds    # Also add sound notifications
jacked install --force --no-tray   # Install without the tray icon
jacked install --no-statusline     # Install without the Claude Code statusline
jacked statusline enable           # Adopt jacked's statusline (saves any existing one)
jacked statusline disable          # Remove it; restores a saved one
jacked uninstall                   # Remove from Claude Code
jacked uninstall --sounds          # Remove only sounds
jacked uninstall --security        # Remove a legacy gatekeeper hook (pre-0.70.0 installs)
jacked check-version               # Check for newer version

# Permissions
jacked permissions audit           # Audit permission rules for dangerous wildcards
jacked permissions audit --fix     # Interactively prune dangerous wildcards

# Dashboard
jacked service status              # Show the background dashboard URL
jacked webux                       # Run a foreground dashboard instead
jacked webux --port 9000           # Custom port
jacked webux --no-browser          # Server only, no auto-open

# Background Service (tray icon ships by default)
jacked service install             # Configure auto-start on login
jacked service start               # Start service with tray icon
jacked service stop                # Stop running service
jacked service restart             # Restart service
jacked service status              # Show evidence-qualified state, build, protocol, port, autostart
jacked service recover             # Safely reconcile a provably owned native definition

# Slash Commands (29 total)
# /dc /dcr /docs-sync /pr /learn /blindspot /redo /retry /techdebt /audit-rules /cleanup
# /qa /qa-video /demo-video /ux /swarm /swarm-research /release
# /whats-next /goal-maker /bhag /jacked-setup
# /cso /lockdown /retro /canary /benchmark
# /land-and-deploy /browser-reset

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [{"type": "command", "command": "\"/path/to/jacked\" _hook qa_suggest", "async": true}]
      }
    ]
  }
}

Install claude-jacked for me.

PHASE 1 - DIAGNOSTICS:
- Detect OS (Windows/Mac/Linux)
- Check: uv --version (if missing: curl -LsSf https://astral.sh/uv/install.sh | sh on Mac/Linux, powershell -c "irm https://astral.sh/uv/install.ps1 | iex" on Windows)
- Check: jacked --version (to see if already installed)

PHASE 2 - INSTALL:
- uv tool install claude-jacked && jacked install --force

PHASE 3 - POST-INSTALL:
- Confirm the running dashboard URL: jacked service status
- Open the reported URL in my browser
- Walk me through adding my Claude accounts from the Accounts page

PHASE 4 - VERIFY:
- jacked --help
- jacked service status (confirm the background dashboard is running)

uv tool update-shell
# Then restart your terminal

# Find the uv tools bin directory
uv tool dir
# Use the full path to jacked if needed

License

MIT

Credits

Built for Claude Code by Anthropic.

The design-engineering skills (emil-design-eng, review-animations, animation-vocabulary, apple-design) come from Emil Kowalski's emilkowalski/skills (MIT), distilled from his work at Vercel and Linear and his course at animations.dev. Bundled with credit and thanks; each skill directory carries his license.