Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

full-send

/full-send

Kończy pracę od początku do końca i scala zmiany, gdy użytkownik wywołuje komendę full-send.

Repozytorium
agent-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

86/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność21 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
8
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Kończy pracę od początku do końca i scala zmiany, gdy użytkownik wywołuje komendę full-send.

Oryginalny opis (EN)

Use when the user invokes `$full-send` to finish work end-to-end and merge.

Jak działa

  1. Grant
  2. Testing permission
  3. Repo rules
  4. Stages
  5. Proof
  6. Review loop
  7. Review rules
  8. Watching
  9. Merge gate
  10. Comment format
Sekcje z nagłówków SKILL.md, w oryginale · 260 linii, 2 362 słów
Podgląd SKILL.md
---
name: full-send
description: Use when the user invokes `$full-send` to finish work end-to-end and merge.
disable-model-invocation: true
---

# Full Send

The user invoked `$full-send`, so they are not watching this thread and want the
work completed end-to-end without them. Your updates and your final message go
unread until long after you stop. You own the work from its current state to a
merged PR.

If the user did not explicitly invoke `$full-send` or clearly ask for full send,
do not assume full autonomy. If they did, everything below applies.

## Grant

The user grants you permission to:

- Merge the PR once the merge gate passes. This is the only agent merge
  authority. It overrides any repo PR skill rule that says "mark ready, then
  stop." Sub-agents never merge.
- Force-push the PR's own branch with `--force-with-lease` after a rebase.
- Use the test methods that Proof needs, without asking first.

## Testing permission

A `$full-send` request is the permission. If a project file or other instruction
says to ask before a test method, or to leave testing to the user, this request
replaces that rule for this task.

That includes ask-first rules for computer use, browser automation, simulators
and devices, running the app or a dev server, screenshots, and visual checks. Use
the method that gives direct proof. List it in the report.

Rules about how to test still apply. Follow rules that name the correct command,
fixture, or check. This permission only removes the ask-first or
leave-it-to-the-user step. If a preferred method cannot prove the change, use a
gated method under this permission.

It covers only the tests needed for this task. It does not add permission for the
steps under "Asking the user", such as production changes or data deletion. It
also does not bypass a harness or system approval prompt if one appears.

## Repo rules

Look up the repo's rules before you open a PR:

- If `.agents/skills/pr/SKILL.md` exists, use it to open the PR. Its
  "mark ready, then stop" rule does not apply here. Full send's merge grant does.
- Otherwise open the PR directly with `gh pr create` as a draft, following
  `AGENTS.md` and `CONTRIBUTING.md`.
- Use the repo's documented CI command. Do not substitute a generic one.

## Stages

Run every stage in order. The user names only `$full-stop` or `$full-send`; picking
the skills is your job. Record each stage as run or skipped, with the reason, and
put that ledger in the report. A stage marked "may skip" needs a stated reason.

| # | Stage | Do |
|---|---|---|
| 1 | Frame | Write the goal, the done condition, what is out of scope, and how you will prove it, before any code |
| 2 | Size | Pick Direct, Design, or Split. See "Routes" |
| 3 | Impact | Use the Blast radius mode of `interrogate`: who and what this touches, and the one fact it is safe because of. May skip only for a local change with no shared code, schema, API, auth, or data |
| 4 | Design | Design and Split routes, when the shape is open: run `architect` |
| 5 | Plan | Split route: run `to-tickets` |
| 6 | Build | Read the `implement` guide. Direct and Design use its TDD loop when there is a cheap test target. Split uses "Fan out a spec". If you are on the default branch, create a branch first. Use the smallest change that works, and fix the case that happened, not every case that could |
| 7 | Prove | Run the proof from stage 1, plus anything impact flagged. See "Proof" |
| 8 | Review | Run each pass in "Review passes". Fix or decline every finding before the next pass |
| 9 | Open the PR | Rebase onto `origin/<base>`, then open the PR with the repo rules above. Write the body through `unslop`, with one short line on how you proved the change unless the template covers it. Use `t3-tools` for the T3 steps. Right after `gh pr create`, call `link_pull_request` with the URL if T3 tools are present |
| 10 | Push and gate | Push the tested commit, run the repo CI command, and wait for the required check to succeed on the head SHA before `gh pr ready`. Then start the watcher. See "Watching" |
| 11 | Babysit | Fix real findings and CI failures. Get proof for each fix before you push it. See "Review rules" |
| 12 | Merge | When the merge gate passes. If the repo uses a merge queue or auto-merge, stay until GitHub reports the PR as merged |
| 13 | Report | The route and why, the stage ledger, the PR link, the merge commit, your proof, the reviewer model used (and any substitution), and each decision you made for the user |

### Routes

Use what this session already shows. If that does not settle it, start one
read-only scout sub-agent on the cheapest capable model. It reports the files and
modules involved, any new or changed public interface or schema, how many slices
could ship independently, and any existing spec, tickets, or ADRs. It does not
edit. The route is your decision, not the scout's.

| Route | Use when |
|---|---|
| Direct | One concern, the shape is obvious, and it fits one session |
| Design | It fits one session, but the shape is open: a new module, interface, or data model, or more than one reasonable design |
| Split | It is too big for one session, or it holds several slices that ship independently |

If a spec or tickets exist, or an agreed `$architect` design does, skip the stages
they already cover. Take the lightest route that fits. If the work proves bigger
than the route, move up one and say so. All routes end in one PR.

### Review passes

| Pass | Runs |
|---|---|
| `code-review` | Every behavior change: repo standards and the spec |
| `interrogate`, review mode | Split route, a real risk from impact, or anything touching auth, permissions, payments, data loss, or concurrency |
| Review loop | Every behavior change. See "Review loop" |

Comment, doc, or format-only changes run the last pass only. `interrogate` findings
count only when a run proves them.

### Models

Every sub-agent model comes from the tiers in the `t3-tools` skill ("Choosing a
model"). That skill also says how to set one and what to do when one fails.

| Work | Tier |
|---|---|
| Scout, build, merge work, `code-review` | Fast. Move a job up to Balanced if a Fast model gets it wrong twice |
| `architect` runners | Strong: Opus plus one OpenCode model, so two families |
| `interrogate` reviewers | Strong: all three models, one per family |
| Review loop | Cheap strong, first model (see `references/review-loop.md`) |

### Loading

`code-review`, `interrogate`, `unslop`, and `t3-tools` are normal skills. Load
`architect` from `/Users/home/.agents/skills/architect/SKILL.md`. Load the others
from `/Users/home/.agents/skills/full-send/routes/<name>/GUIDE.md`: `to-tickets`
and `implement`.

Nobody is watching, so these rules override those skills and guides on this task:

- Where they say to check with the user (seams, the ticket breakdown, which
  candidate to pursue, unclear intent), decide yourself and list the decision in
  the report.
- `grilling` needs the user, so do not run it here.
- If the repo has no tracker docs, use the local ticket form in `to-tickets`.
- Replace the final review and "mark ready" steps in `implement` with stages 7 to
  13, run on the integration branch.
- Merger sub-agents may merge worktree branches into the integration branch. Only
  this thread merges the PR.
- A missing decision about how to build it is yours. A missing decision about
  what to build falls under "Asking the user". If several are missing, stop and
  tell the user to run `$architect` first.

Stay active from stage 1 to stage 13. If you end your turn while checks or reviews
are pending, the work stops, because nobody will prompt you again. Wait with the
watcher so something wakes you when the PR changes. If you stop before the merge,
call `unwatch_pull_request` first.

## Proof

Proof is evidence you observed yourself in this session: command output, a
reproduction, a screenshot. Use the most direct proof the change allows:

- Reproduce the original failure, apply the fix, then watch the same reproduction
  pass.
- Run the repo's documented CI command.
- Add one focused test that fails without the fix, when the behavior has none and
  the repo has a test setup.
- For UI and runtime behavior, run the app and look at the change. Green mocked
  tests do not prove that the user experience works. Attach screenshots to the PR
  when they help and you have a way to upload them.

When you cannot find a way to prove a change, you do not have full confidence.
Ask the user.

## Review loop

Before stage 8's last pass, read `/Users/home/.agents/skills/full-send/references/review-loop.md` and follow it. It holds the
reviewer model, budget, round brief, and stop rules.

## Review rules

Only act on checks and comments newer than the latest push. Verify every review
finding against the source before you change code. Fix real findings and CI
failures. Distinguish repository failures from infrastructure flakes. When you
dismiss a false positive, reply with a written reason and resolve the comment.

- Any auto-review on the head has finished, and each finding is fixed or
  dismissed with a written reason.
- If the repo has `.macroscope/check-run-agents/*.md`, read those rules before you
  reply to a Macroscope finding. Its findings cite them.
- CodeRabbit is advisory. Treat its findings like any other finding, but never
  wait for it and never hold a merge for it.
- Keep the PR at the size the goal needs. Review loops tend to grow a PR one
  cheap-looking fix at a time. Fix real bugs in the intended case. Decline the
  rest with a written reason and list them as follow-ups: unneeded tests, guards
  for edge cases that do not matter, extra integration or compatibility, and small
  performance costs. Prefer the fix that deletes or narrows code.
- If nothing has changed, stay quiet rather than posting filler comments.
- If an overlapping PR makes this one obsolete, stop, report it to the user, and
  ask before closing the PR.

## Watching

Use one watcher per PR. Never write your own polling loop or `sleep` loop, and
never run two watchers on the same PR.

- In T3 Code, handle the existing checks and comments first. Then call
  `watch_pull_request` and end your turn. T3 Code wakes you when a check fails,
  the required checks pass, someone comments or reviews, or the branch conflicts.
- Outside T3 Code, poll the head check-runs with `gh api` in one background
  command at a modest interval. Never run a tight loop.
- Only the thread that owns the PR watches it. If you are a delegated child task
  (a reviewer or any `delegate_task` child), never call `watch_pull_request`.
- A wake is news, not a merge decision. Check the merge gate yourself.
- Unwatch when you hand off. Call `unwatch_pull_request` before you stop, whether
  the PR is ready, blocked, or you are asking the user. A merge or close ends the
  watch on its own.
- Use `gh api repos/<owner>/<repo>/pulls/<n>` and
  `gh api repos/<owner>/<repo>/commits/<sha>/check-runs` to read the PR and its
  checks. `gh pr view` and `gh pr checks` use GraphQL, which runs out first.
- "Stopped watching, could not read it" usually means the GitHub rate limit is
  used up. Run `gh api rate_limit --jq .resources.graphql` before you watch again.
  If `remaining` is near 0, wait for `reset` with one background command, then
  watch again. Never watch again in a tight loop.
- Before a merge, run `git fetch` and check the PR again. Never merge when it is
  BEHIND or DIRTY, or when base commits that landed after the last green run touch
  this PR's files. Rebase, push, and wait for green again.

## Merge gate

Full confidence means all of these are true on the latest commit:

- Your proof covers every change in the diff.
- Trust the forge's verdict, not a green check list. Ready means the forge agrees
  the PR can merge: read the status of the current head SHA and require the
  required check to be success. After any amend, rebase, or base update, rerun CI.
  Exit 0 is not the gate.
- Any auto-review on the head has finished, and each finding is fixed or dismissed
  with a written reason.
- No human review still requests changes.
- The branch is up to date with its base, and GitHub reports it as mergeable.

Merge with the method the repo allows. If its docs do not say, read
`allow_squash_merge`, `allow_merge_commit`, and `allow_rebase_merge` from
`gh api repos/<owner>/<repo>`. Never use `--admin` or other bypasses. Merge only through
branch protection as configured.

## Comment format

Before you post any comment on the user's behalf, read
`/Users/home/.agents/skills/full-send/references/comment-format.md` and follow it.

## Asking the user

A question in a normal message goes unseen, and the thread looks done. To ask the
user something, use the harness's question tool so the thread shows that it is
waiting: `AskUserQuestion` in Claude Code, `request_user_input` in Codex, or the
question tool your harness has. Put all the context in the question: the PR link,
what blocks you, and the options with your recommendation first.

Ask only when you cannot continue alone:

- You cannot prove the change.
- The merge gate cannot pass, and you cannot fix that yourself.
- The next step is outside the grant above: deleting data, touching production,
  changing things outside the repo, closing a PR, or force-pushing any other
  branch.
- The goal is ambiguous in a way that changes the result.
- Another PR makes this one obsolete.

Decide everything else yourself with sensible defaults, and list those decisions
in the report.

If no question tool is available, or the tool returns no answer, take the safe
path: leave the PR open and unmerged, and start your final message with the
question.
Pliki w paczce (8)
  • SKILL.md 13 KB
  • agents/openai.yaml 1 KB
  • references/comment-format.md 1 KB
  • references/review-loop.md 4 KB
  • routes/implement/GUIDE.md 7 KB
  • routes/implement/mocking.md 1 KB
  • routes/implement/tests.md 2 KB
  • routes/to-tickets/GUIDE.md 8 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · RIJUDEVx/agent-skills86MIT
adelrodriguez/skills96MIT
colinmollenhour/dotfiles90Apache-2.0
cravingmaker/skills90MIT

Migawka bazy z 13.11.2026 · wersja paczki 242dd879d04c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100full-stop
    Kończy pracę od początku do końca i zatrzymuje się z gotowym pull requestem, który użytkownik scala sam.
  • 100merge
    Kończy pracę w worktree Herdr: zatwierdza zmiany, robi rebase, scala i sprząta, tylko na jawne polecenie /merge.
  • 100git-worktree-finish
    Kończy pracę w worktree utworzonym przez git-worktree i scala ją z powrotem do głównej gałęzi.
  • 90worktrees:finish
    Kończy pracę w worktree: tworzy pull request lub scala gałąź bezpośrednio, usuwa worktree i sprząta gałąź roboczą.
  • 100finish-branch
    Kończy gałąź funkcji: uruchamia testy, sprawdza README, CHANGELOG i wersję, scala z główną gałęzią i sprząta gałąź.
  • 100full
    Przeprowadza zgłoszenie Linear od początku do końca: uruchamia /start, potem /finish, zależnie od werdyktu /quality-review, z tokenami wt, auto, simple, pr i push.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.