yeet

name: yeet description: Canonical repo-quality operator workflow for beep-effect. Use when repairing local changes, proving quality, committing, pushing, opening or monitoring a PR, or moving a branch toward mergeable GitHub state with `bun run beep yeet`.

Yeet Quality Path

Use this skill when a user asks to repair, verify, publish, push, open a PR, or make a branch mergeable in this repository. Yeet is the canonical operator path for End-to-End Green: deterministic local repair, full local proof, reviewed commit, push, PR checks, review closeout, and merge readiness.

Ground First

Inspect the current branch and worktree:

git status --short --branch
git diff --name-status

If the checkout is on main or another protected/default branch, create a feature branch from the intended base before editing or publishing. 2b. Check base freshness before publish:

git fetch origin main:refs/remotes/origin/main --quiet
git rev-list --count "$(git merge-base HEAD origin/main)"..origin/main

Yeet publish warns whenever the branch is behind origin/main and refuses when branch files overlap commits landed on the base since the merge-base (a conflicted or stale PR is likely). Rebase onto origin/main first; --allow-stale-base is the explicit override. 3. If the worktree contains unrelated changes, stage only the intended files. Never publish unrelated paths silently. 4. Check for already-running heavyweight quality commands before starting a Yeet lane:

ps -eo pid,ppid,stat,etime,cmd | rg 'bun run|beep yeet|audit:github|turbo|gh pr|git ' | rg -v 'rg|ps -eo' || true

Canonical Commands

Repair local work:

bun run beep yeet repair

Prove the branch without committing or pushing:

bun run beep yeet verify

Run the targeted review-fix proof while iterating on PR comments:

bun run beep yeet verify --tier review-fix

Commit reviewed staged changes, run the full local pre-push proof, then push:

bun run beep yeet publish --message "type(scope): summary"

Publish exactly the staged index from a dirty worktree (unstaged/untracked residue is parked in a marked stash after the commit, the clean tree is proven, and the stash is restored after push; on a restore conflict the stash is kept and its marker reported):

bun run beep yeet publish --staged-only --message "type(scope): summary"

Create the pull request in-flow after a green push (skips when an open PR already exists; composes with --staged-only, --monitor, and --start-pr-early):

bun run beep yeet publish --pr --monitor --message "type(scope): summary"

Reply to and resolve addressed review threads during closeout (explicit per-thread flags; closeout never writes without them):

bun run beep yeet closeout --reply-thread <thread-id> --reply-body "Fixed in <sha>." --resolve-threads <thread-id>[,<thread-id>...]

Start hosted PR review/checks immediately, then keep proving locally:

bun run beep yeet publish --start-pr-early --monitor --message "type(scope): summary"

Retry after a separately verified amend without creating a new commit:

bun run beep yeet publish --amend --no-edit --reuse-verified

Push an already-verified clean commit without committing or rerunning local proof:

bun run beep yeet publish --push-only --reuse-verified

Monitor hosted PR checks for the current branch:

bun run beep yeet monitor

Read the local Yeet operator state before scanning logs. This is local-only by default and reads branch/worktree state plus the latest Yeet artifacts:

bun run beep yeet status
bun run beep yeet status --json

Include live GitHub PR/check/mergeability data only when you need it:

bun run beep yeet status --remote

Print compact operator summaries for hosted monitor or closeout flows:

bun run beep yeet monitor --summary
bun run beep yeet closeout --summary --require-greptile-score 5/5 --require-greptile-issues 0 --require-review-comments 0

Inspect hosted review/bot closeout gates for the current branch PR:

bun run beep yeet closeout --require-greptile-score 5/5 --require-greptile-issues 0 --require-review-comments 0

Inspect local hardware profile guidance before choosing heavy parallel work:

bun run beep quality profile detect
bun run beep quality profile config workstation

Use plan mode before long or risky runs when you need to inspect the shape:

bun run beep yeet repair --plan --json
bun run beep yeet verify --plan --json
bun run beep yeet verify --tier review-fix --plan --json
bun run beep yeet publish --message "type(scope): summary" --plan --json
bun run beep yeet status --remote --plan --json
bun run beep yeet monitor --summary --plan --json
bun run beep yeet closeout --plan --json

Mergeable PR Workflow

Run bun run beep yeet repair when local changes need deterministic fixers, docgen, repo-export catalog repair, or affected feedback.
Stage the reviewed files explicitly.
Run bun run beep yeet status when you need a compact local readiness snapshot before publishing.
Run bun run beep yeet publish --message "type(scope): summary".
If no pull request exists for the pushed branch, prefer publishing with --pr so Yeet creates a ready PR from the commit log and local proof summary; gh pr create --draft --fill remains the manual fallback.
Run bun run beep yeet monitor --summary for hosted checks when compact operator output is enough; omit --summary when you need the full stream.
Run bun run beep yeet closeout --summary --require-greptile-score 5/5 --require-greptile-issues 0 --require-review-comments 0 to inspect unresolved actionable review threads and review-bot gates.
Use bun run beep yeet verify --tier review-fix while fixing PR comments, then use normal Yeet publish or the exact-match amend retry when appropriate.
Address failed checks or actionable review comments with follow-up commits through the same Yeet publish path.
Mark the PR ready only when checks are green, there are no unresolved actionable review threads, and GitHub reports the branch as mergeable or not conflicted.

yeet closeout is read-first. It classifies review threads and bot findings and writes Yeet artifacts locally. It posts a Greptile rerun comment only when --retrigger-greptile is explicit, and it does not auto-resolve or auto-reply to review threads. The closeout artifact includes durable states for review threads, Greptile, CodeRabbit, ChatGPT, and hosted-check handoff.

Fast Plus Monitor

bun run beep yeet publish --fast --monitor --message "..." is opt-in only. Use it only on an existing PR branch when the user explicitly accepts replacing the local full pre-push wait with hosted PR-check monitoring. It must remain paired with --monitor; Yeet rejects --fast without it.

bun run audit:github pre-push remains the named full local fallback for secrets, security, SAST, Nix, and any lane that must be proven outside Yeet.

Start PR Early

bun run beep yeet publish --start-pr-early --monitor --message "..." is the explicit fail-faster path for an existing PR branch. It validates the commit message, commits and pushes with Git hooks skipped, then still runs the full local pre-push proof and hosted PR monitor. Unlike --fast, it does not skip the local full proof; it only overlaps that proof with hosted CI and reviewer startup time.

Use it when the user wants remote checks and reviewers moving in parallel with a local proof cycle. If the post-push local proof fails or writes files, fix the issue in a follow-up commit and publish again. Treat commit/pre-push hooks as local tripwires and proof-reuse adapters; Yeet full proof plus hosted checks are the authoritative gates.

Run Artifacts

Every non-plan Yeet run writes .beep/yeet/runs/<branch>/verdict.json (yeet-verdict/v1): outcome, per-lane status, repair command for each failed lane, packet paths, staged-only stash identity, and base-freshness data. Read yeet status or the verdict before scanning logs. yeet status is observational and writes .beep/yeet/runs/<branch>/status.json instead of replacing the latest verdict.
Failure packets land under .beep/yeet/packets/ with the quality-issue index at .beep/yeet/quality-issue-index.json.
The local pre-push proof includes changeset status --since=origin/main (parity with hosted Repo Sanity). For intentionally version-neutral changes, run bunx changeset add --empty and commit the empty changeset.

Failure Handling

If Yeet fails after creating a local commit but before pushing, fix the issue. When you prove the exact current worktree with bun run beep yeet verify, you may retry with bun run beep yeet publish --amend --no-edit --reuse-verified. Yeet reuses only exact matching full-proof state; if the state is stale, rerun full proof or publish normally.
If the current clean commit was already verified and only the push was blocked or skipped, prefer bun run beep yeet publish --push-only --reuse-verified. Yeet still requires exact reusable proof state and a clean worktree, and it pushes with git push -u origin HEAD so upstream branch naming cannot block agent-created feature branches.
Yeet publish marks its git push with an exact-proof reuse hint for the pre-push hook. The hook reuses only matching full-proof state for the pushed SHA and falls back to its normal repo-export catalog validation when state is absent, stale, dirty, or ambiguous. Treat this as duplicate-proof reuse, not a hook bypass.
--start-pr-early is the only Yeet publish mode that intentionally skips commit and pre-push hooks. It requires --monitor, still runs full local proof after pushing, and should fail loudly rather than hiding follow-up work.
If Yeet refuses untracked, unstaged, or newly generated paths, inspect the paths and decide whether they belong in the reviewed publish intent.
Yeet serializes full local proof runs with .beep/yeet/quality-lock. verify --tier review-fix remains the cheaper loop lane while a full proof is already active. Locks whose recorded pid is no longer running are removed automatically on the next acquire; manual removal is only needed for unreadable lock files.
Full pre-push proof streams a conservative collector for independent GitHub check lanes. A failed proof may report multiple sibling failures at once (for example check, lint, repo-export, tests, SAST, or Nix). Fix all reported actionable lanes before retrying instead of assuming the first item is the only blocker.
Failure packets are written for proof/commit/publish/monitor step failures, publish-intent refusals (untracked/unstaged/partially staged paths), and stale-base refusals. Intent refusals print a summarized path list on stderr; the full list lives in the packet. Known sub-lane hints cover cspell, typos, terse-effect, dual-arity, repo-export catalog, docgen, changeset status, secrets, SAST, security, and Nix. Hint selection prefers output near the actual failure marker before falling back to broad log scanning. Prefer the suggested repair command in yeet status, the packet, or verdict.json over rerunning the whole loop blindly.
Root composite lanes prefer streaming accumulation where child commands are independent. For example, root lint streams the Turbo/Biome aggregate and then still runs repo-law policy lints, so one lint-family failure does not hide sibling lint findings.
The root docgen lint check uses package-local docgen proof manifests. A package with a current .beep/docgen/proof.json can skip duplicate docgen metadata analysis; missing or stale manifests fall back to the normal check.
Terse-effect output separates blocking, rewritable, and informational files. Use --write only for the rewritable helper subset; manual candidates still need direct edits.
If there is no open PR for yeet monitor, create the draft PR first or run bun run audit:github pre-push as the full local fallback.
If yeet closeout reports Greptile score/issues as unknown, inspect the PR comments and rerun Greptile explicitly with --retrigger-greptile only when the user wants that GitHub write.
Do not weaken GitHub check names, hosted PR checks, or manual fallback lanes to make a branch appear green faster.

name: yeet description: Canonical repo-quality operator workflow for beep-effect. Use when repairing local changes, proving quality, committing, pushing, opening or monitoring a PR, or moving a branch toward mergeable GitHub state with bun run beep yeet.