tabstax-cli

hey — TabStax CLI

Log what you're doing. See what the team is doing. Stay in flow.

hey is the terminal interface for TabStax — a lightweight command for individuals and teams to track next actions, breadcrumb decisions, and coordinate work without leaving the tools where the work actually happens: your shell, your editor, Claude Code, or a CI pipeline.

npm install -g tabstax-cli

Requires Node.js 18+ and a TabStax account.

The idea

Most task tools pull you out of flow. You stop, switch to a browser, navigate, type something, switch back. Two minutes gone, context broken.

hey is one command. You're already in the terminal. Log the next thing, see the team board, mark something done — and you're back. Every action is synced to the TabStax web app and the browser extension, with your @handle attached, so the team always sees who's doing what without a standup.

Works wherever you work:

Where	How
Terminal	hey "message" — one command, no context switch
Claude Code	Ask Claude to read hey ls --all and act on it
Web app	dash.tabstax.app — attention board with handle pills and filters
Browser extension	Start Here page per project, actions synced live
CI / scripts	Pipe failures, deploys, or events directly into a shared stax

Quick start

hey login
hey use "my-project"
hey "Fix the token refresh race condition"
hey ls
hey done 1

Commands

Add and complete actions

Command	Description
hey "message"	Add a next action to your current project
hey -x "message"	Log a breadcrumb — something you already did
hey done [n]	Mark action #n as done (default: first action)
hey rm <n>	Remove action #n
hey edit <n> "text"	Edit action #n
hey mv <from> <to>	Reorder: move action to a different position

See what's on

Command	Description
hey ls	List actions for the current project
hey ls stax	All your projects with priorities
hey ls --all	Expanded: top 3 actions per project
hey ls --done	Breadcrumbs — what's been completed
hey ls -c 20	Show up to 20 items

Projects and context

Command	Description
hey use <project>	Switch default project (fuzzy matched)
hey which	Show current project and logged-in user
hey pri <project> <level>	Set priority: must should good meh

Auth

Command	Description
hey login	Log in (interactive, password masked)
hey logout	Log out
hey whoami	Show current user and handle
hey status	Session and config summary

For individuals

Daily dev flow

# Morning: pick up exactly where you left off
hey use "backend-api"
hey ls

# Log as you go — one line, stay in the terminal
hey "Investigate N+1 query in /dashboard endpoint"
hey "Write test for edge case in token refresh"
hey -x "Fixed auth middleware — sessions now persist across restarts"

# End of day
hey ls --done

Keeping a decision log

The -x flag is for breadcrumbs: things you already did, decisions made, or context you want to preserve. They appear in the Start Here page on the extension so future-you (or a teammate) can see why the project is in its current state.

hey -x "Decided against Redis for session cache — latency was fine without it"
hey -x "Upgraded to Postgres 16 — no breaking changes, pooler config updated"
hey -x "Deprioritised dark mode until v2 — product call on 2026-03-03"

For teams — collaborative stax

Add collaborators to a stax and now all work is together in flow. No Jira board, no Notion page, no standup doc — just a shared list of what's next, updated in real time from wherever each person works. Excellent for high-velocity work where you're just building rapidly.

How it works

• Owner opens dash.tabstax.app, finds the stax, and sets it to Collaborative from the share menu
• Add collaborators by their @handle — they get access instantly
• Each person runs hey use <stax-name> once
• Everyone adds actions from wherever they work — terminal, Claude Code, CI scripts
• The web app and Start Here page show each person's actions with a colour-coded handle pill
• A filter bar lets anyone narrow by contributor in one click

# Join a team stax
hey use "sprint-47"

# Add your actions — they'll show up under your @handle
hey "Implement OAuth handshake"
hey "Write migration for invites table"

# Log what you shipped
hey -x "Deployed API gateway — load balanced across 3 nodes"

# See the full team board
hey ls

# Check all projects
hey ls stax

Every action is visible in real time on dash.tabstax.app — no standup needed to answer "what's everyone working on?"

@handle attribution

Every action added via hey is tagged with your @handle (set when you create your TabStax account). In the web app and the extension Start Here page:

• Each action shows a pastel @handle pill to the right of the text
• Colour is consistent per person across all views and projects
• A filter bar lets you show one or more contributors' actions at a time
• Done actions can be shown or hidden independently

Check your handle:

hey whoami

Team workflows

Sprint coordination

# Sprint kickoff: team lead creates the stax, everyone joins once
hey use "sprint-47"

# During the sprint: add as you pick up work
hey "Implement dark mode toggle"
hey "Write unit tests for payment service"

# Mark done as you go — updates the board for everyone
hey done 1

# Sprint review: full breadcrumb trail of what shipped
hey ls --done

Incident response

When something breaks, hey gives every responder a shared log so nothing gets lost between shifts or calls.

# Everyone joins the incident stax
hey use "incident-2026-03-03"

# Log what you're trying in real time
hey "Check database connection pool — seeing timeouts"
hey "Rolling restart of API pods"
hey -x "Confirmed: root cause was stale connection pool config"
hey done 1

# Hand off cleanly — full timeline is in the web app
hey ls --done -c 50

AI agent governance

When multiple AI agents are running in parallel (Claude Code subagents, CI bots, automated pipelines), hey gives you a shared log of what each agent did. Point each agent at a shared stax and every action and decision is recorded with attribution.

# Each agent logs to the shared stax before and after major steps
hey -x "Agent:researcher — analysed 47 files, found 3 auth patterns"
hey -x "Agent:coder — implemented OAuth flow, 312 lines changed"
hey "Agent:tester — run contract tests before merge"

The web app shows the full timeline, colour-coded by agent, so a human reviewer can see exactly what happened and what still needs sign-off.

Open source / research coordination

hey use "oss-backlog"

hey "Review PR #412 — new auth provider"
hey "Triage issues labelled good-first-issue"
hey -x "Merged PR #389 — storage quota fix"

Why sharing is just "add collaborator"

Set up sharing from the dashboard at dash.tabstax.app — click the share icon on any stax, switch to Collaborative, and add team members by @handle. That's it. No invite links, no permissions matrix. The mental model is simple:

• Your stax = your project context (tabs + next actions)
• Collaborative stax = same thing, but the team can see and contribute
• hey in terminal = the fastest way to add to it

When you add a collaborator, they immediately see the stax on their attention board and can hey use it from the CLI. Actions flow in from all directions — one person in VS Code, another in Claude Code, a third on mobile — and everything merges into the same timeline with @handle attribution.

This is built for teams that ship fast and communicate through the work itself, not through status updates about the work.

Timesheets

Track weekly hours from the terminal. Timesheets live at time.tabstax.app and are also accessible via CLI.

Commands

Command	Description
hey ts	View current week's timesheet
hey ts 8	Set Mon–Fri to 8h each
hey ts wed 7.5	Set single day hours
hey ts mon=8 tue=7 fri=6	Matrix input — multiple days at once
hey ts submit	Submit current week for approval
hey ts reopen	Reopen a submitted timesheet
hey ts ls	List past 8 weeks
hey ts ls --all	Full timesheet history

Flow

# Friday afternoon: log your week
hey ts 8                     # 8h Mon-Fri
hey ts fri 6                 # actually left early Friday
hey ts submit                # done — shows up for admin approval

# Oops, forgot Thursday was a half day
hey ts reopen
hey ts thu 4
hey ts submit

Timesheets show evidence counts (actions logged per day) alongside hours — so approvers can see what was actually done, not just what was claimed.

Claude Code integrations

hey + Claude Code turns your stax into a programmable task queue. Because hey ls outputs plain text, Claude can read, reason about, and act on it directly.

Morning standup digest

Read my current stax using `hey ls --all` and write a short standup update
I can paste into Slack. Group by project, highlight the top action per project,
and flag anything that's been sitting for more than 3 days.

Sprint health check

Run `hey ls stax` to see all my projects. For any project at 6+ actions out of 7
(near the limit), suggest which actions could be combined, deferred, or done first.
Output a prioritised plan.

Incident post-mortem

The shared stax "incident-2026-03-03" has a full breadcrumb trail.
Run `hey ls --done -c 50` to get all completed actions.
Draft a post-mortem with timeline, root cause, and action items.

Auto-log CI failures

# In your CI script — on test failure:
hey "CI failed: $(git log -1 --pretty='%s') — $(git rev-parse --short HEAD)"

Watch `hey ls` for actions containing "CI failed". For each one, look up
the commit, fetch the test output, and suggest a fix.

End-of-week retrospective

Run `hey ls --done -c 100` across my top 3 stax. Summarise what shipped
this week, what's still in flight, and suggest 3 focus areas for next week
based on what's been sitting longest.

Features

• 7-action limit per project keeps lists focused and forces prioritisation (--force to bypass)
• Fuzzy project matching — hey use tab matches "TabStax Backend"
• Priority icons — ★ must · ◆ should · ○ good · · meh
• Breadcrumbs (-x) — log decisions and completed work, not just what's next
• @handle attribution — every action tagged to you; colour-coded pills in web + extension
• Shared stax — any team member can add to a collaborative stax; syncs in real time
• Auto session refresh — stays logged in across restarts; prompts cleanly on expiry
• Works in CI/scripts — no interactive mode required for adding actions

Session management

Sessions use a long-lived refresh token and auto-refresh 5 minutes before expiry. You won't be interrupted mid-session. If your refresh token expires (7+ days of no use), you'll get a clear prompt to re-login.

hey login    # interactive, password masked
hey whoami   # check session state
hey status   # full config + auth info

Links

• TabStax
• Attention board
• Chrome Web Store
• GitHub
• Issues

License

MIT