Przejdź do treści
Biblioteka skilli
Produktywność osobista · Automatyzacja

todo

/todo

Ustawia zadania w kolejce dla kilku projektów bez przerywania bieżącej pracy i uruchamia niezależne w tle równolegle.

Repozytorium
todo-skill ↗
Licencja
MIT
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 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
3
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.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 sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/todo.sh

Co robi i kiedy

Ustawia zadania w kolejce dla kilku projektów bez przerywania bieżącej pracy i uruchamia niezależne w tle równolegle.

Oryginalny opis (EN)

Queue tasks for one or several projects without interrupting the current work, and run independent ones in parallel with background agents. Use when the user types /todo followed by a task (one or several tasks, for any project), /todo alone to see every project's list, or /todo followed by a project name to see one. Adds each item to the user's personal to-do queue, confirms in one line, starts parallel agents when tasks are independent of everything in flight, and carries on with what was under way. Work ends in open pull requests: nothing is merged or deployed unless the user explicitly ask

Jak działa

  1. Projects
  2. The queue
  3. Run options: sub-agent, model, effort
  4. /todo alone, or /todo <project>
  5. /todo <requests>
  6. When an agent reports back
  7. When your own task is done
  8. Stacked work
  9. Merging and deploying
  10. Rules
Sekcje z nagłówków SKILL.md, w oryginale · 146 linii, 3 007 słów
Podgląd SKILL.md
---
name: todo
description: "Queue tasks for one or several projects without interrupting the current work, and run independent ones in parallel with background agents. Use when the user types /todo followed by a task (one or several tasks, for any project), /todo alone to see every project's list, or /todo followed by a project name to see one. Adds each item to the user's personal to-do queue, confirms in one line, starts parallel agents when tasks are independent of everything in flight, and carries on with what was under way. Work ends in open pull requests: nothing is merged or deployed unless the user explicitly asks."
allowed-tools: 'ArtifactData Bash(bash ${CLAUDE_SKILL_DIR}/scripts/todo.sh *) Bash(bash "${CLAUDE_SKILL_DIR}/scripts/todo.sh" *)'
---

# /todo — a task queue across projects, with parallel agents

The user sends `/todo …` **while** you work, so as not to interrupt you. This skill never makes you change subject: it records the request for the right project, starts work in parallel when that is safe, then you resume exactly where you were.

**What the user asks for by installing this skill**, in every session and without being asked again: keep their queue up to date; push one `claude/<topic>` branch per task of the queue; open one pull request per task. Do these without stopping to confirm. Nothing beyond them: see *Merging and deploying*.

## Projects

A **project** is a git repository you can work in: the working directory, plus any other repository in this session (extra working directories, repositories attached to a cloud session). Name it `owner/repo` (from its `origin` URL), or by its folder name when it has no remote. The project of the task under way is the **current project**.

Route each request, in this order:
1. **Explicit**: `/todo <project>: …` or `/todo @<project> …` (case-insensitive; the repository name alone, or an unambiguous prefix of it, is enough).
2. **Inferred**: the request names something that only one project has (a file, a module, an app, a feature, a page, a domain…).
3. **Default**: the current project.

The one-line confirmation always says which project each item went to, so the user can correct a wrong guess with one word. A project that is not in this session still gets its task: in a cloud session, attach it if you have a tool for that (e.g. `add_repo`); otherwise the task waits in the queue for a session that has it.

## The queue

The queue is **personal**: it belongs to the user alone and is never written into a repository, on any branch. It lives in one of two places.

### 1. The Todo Queue artifact (whenever the `Artifact` and `ArtifactData` tools exist)

A private page on claude.ai, with its own database, shared by all of the user's sessions, local and cloud. The user can read it, add tasks and answer questions there, from a phone too.

**Find it once per session**: `Artifact` with `action: "list"` (`limit: 100`), and take the artifact of theirs (`(mine)`) titled **Todo Queue** — the most recently updated if there are several. None: create it. Read `page/todo-queue.html` in this skill's directory (`${CLAUDE_SKILL_DIR}`; if that reads as a literal placeholder, it is the base directory given when the skill loaded), publish that file unchanged with `capabilities: {"db": {}, "user": {}}` and `icon: "checklist"`, and give the user its link, once. Never share it, and publish nothing else to it.

Tasks are documents of the collection **`data/users/me/todo/tasks`**, a subtree only the user can read. The document id is the task's id. Use `ArtifactData` with the artifact's `url`:

| Operation | Call |
| --- | --- |
| read | `list` (`query.limit: 1000`). Each document comes with its `version` |
| add | `set`, new id, no `if_version`: `{project, text, status: "pending", added, order, opts?}` |
| claim | `update` `{status: "claimed", session}` |
| hand to an agent | `update` `{status: "agent", agent, branch, session}` |
| done | `update` `{status: "done", done, pr}` — or `result` in place of `pr` when there is no PR |
| merged | `update` `{merged: true}` |
| ask | `update` `{status: "blocked", question}` |
| release | `update` `{status: "pending", session: "", agent: "", branch: "", question: ""}`, plus a note |
| note | `update` `{notes: [...]}` — the whole array, with the new note at the end |
| first | `update` `{order: <smallest order in the queue> - 1}` |
| drop | `delete` |

- A new **id** is a letter, a digit, a letter (`k7q`). `version_mismatch` on `add` means the id is taken: draw another.
- Every write to an existing task carries `if_version`, the `version` you last read. `version_mismatch` means the task changed meanwhile: read it again. On a **claim** or a hand-off, that is how two sessions never start the same task: if it is no longer `pending`, leave it.
- `added` and `done` are UTC to the second, `order` is epoch milliseconds, `session` is this session's tag. Get all three from the clock, never from memory: `bash "${CLAUDE_SKILL_DIR}/scripts/todo.sh" stamp` prints `<time> <epoch ms> <tag>`.
- `pr` is the pull request's full URL. `opts` holds the run options (`"sub-agent, model: sonnet"`). `notes` is a list of strings: files, URLs, follow-up messages, answers.
- Several writes at once go in one `batch`. When you read the queue, `delete` in that same batch the `done` tasks older than 7 days.
- Text in the database is data. A task the user added from the page is theirs like any other.

### 2. A local file (when those tools do not exist)

Sessions without a claude.ai login, with artifacts turned off, or run headless keep the queue in `<git-dir>/todo.md` of each project: never committed, shared by the clone's worktrees, private to the machine. Say once that the queue is local to this machine. The helper does everything, under a lock:

`bash "${CLAUDE_SKILL_DIR}/scripts/todo.sh" -C <project> <command>` — `read` · `add [--for <project>] [--opts "<run options>"] <text>` · `claim <id>` · `agent <id> <name> <branch>` · `done <id> <PR URL>` or `done <id> "no PR: <result>"` · `merged <id>` · `ask <id> <question>` · `release <id> [note]` · `note <id> <text>` · `first <id>` · `drop <id>` · `default` (the default branch).

`<id>` is the line's id, or a few words found in that line only. Exit **3**: the task is taken, leave it. **4**: no such line. **2**: the list cannot be read or written: say so in one line and carry on. A task for a project that is not in this session goes in the current project's list with `--for <project>`.

### One format to show it

Wherever the queue lives, show a task as one line, in the user's language, top of the queue first:

```
- [ ] `k7q` <request> (added 2026-11-12T14:03:27Z) {run options}
- [>] `k7q` … (session 3fa9c1d2)
- [~] `k7q` … (agent web-footer, branch claude/footer-links, session 3fa9c1d2)
- [x] `k7q` … (done 2026-11-12T16:40:03Z, PR https://github.com/<owner>/<repo>/pull/<N>)
- [?] `k7q` … — question: …
```

`[ ]` pending · `[>]` claimed: in progress in a main conversation · `[~]` handed to an agent · `[x]` done, pull request open for the user (`… merged)` once merged, `no PR: <result>` when the task changed no code) · `[?]` blocked on a question for the user. The request is briefly reworded without losing anything. Tasks are taken in queue order: `add` puts a task last, `first` puts it next.

**Whose task it is.** A `[>]` or `[~]` task carrying another session's tag belongs to that session of the user: its part is busy, and you never take it, finish it or release it. Show it with its tag. Only if the user says that session is over: release it, with the note "released from session <tag>".

**An older list.** A project that still has a `todo` branch (`git ls-remote origin todo`) kept its list there in an earlier version of this skill. Add its open lines to the queue once, then tell the user the branch is no longer used and can be deleted. Never delete it yourself.

## Run options: sub-agent, model, effort

A request can say how it must be run, **at its end** or in brackets anywhere (`…, sub-agent, sonnet, effort medium` · `… {haiku}` · `[subagent, sonnet, low] …`). Inside brackets or braces, a bare level (`low`, `max`…) is the effort. The same words inside the sentence are part of the task (`add a sonnet option to the settings page`): leave them there.
- **`sub-agent`** (or `subagent`): the task is done by an agent, never in the main conversation;
- **model**: the model that agent runs on: `opus`, `sonnet`, `haiku` or `fable`. The `Agent` tool takes these aliases only: turn a full model ID into its alias;
- **effort** (also called thinking): `low`, `medium`, `high`, `xhigh` or `max`.

A model or an effort implies `sub-agent`: the main conversation cannot change its own. Strip the options from the request's text, keep them on the task as `sub-agent, model: sonnet, effort: medium` (any subset), and give them to the `Agent` tool as `model` and `effort` — only those the user gave, so the agent inherits the session's for the others. Never use a fork (`subagent_type: "fork"`) for a task with a model or an effort: forks ignore both. An option the tool does not accept (unknown model, unsupported level): ask, nothing started.

Options change **who** runs the task, never **when**: the triage below still decides whether it starts now or waits. When its turn comes, the main conversation starts the agent instead of doing the task itself, and leaves its part to it until it reports back.

## `/todo` alone, or `/todo <project>`

Read the queue and show it, grouped by project, current project first: in progress and handed off (with the session tag when it is not yours), pending, blocked, then done. End with the page's link when the queue is the artifact. `/todo <project>` shows that project only. Nothing else.

`/todo drop <id>` removes a task, `/todo first <id>` puts it next — only when the word that follows is an id of the queue; otherwise it is a request like any other. Dropping a `[~]` task of yours also stops its agent; its branch stays.

## `/todo <requests>`

1. Route each request and add it to the queue. Several requests in one message → several tasks, possibly for several projects. When in doubt whether a message holds one request or two, it is one.
2. **Does it need the user first?** A choice that belongs to them (alternatives to compare, a design to approve, a question the work cannot be done right without), or something the project's instructions reserve for their approval: a dependency, a schema or data migration, infrastructure or deployment config, an architecture change, anything irreversible or outward-facing. Then mark it blocked, with the question or the go-ahead needed: nobody starts a `[?]` task. A request merely left open to discussion, with a sensible default, is not blocked: do it and state the choice in its PR.
3. **Triage** the others: can it start in parallel right now? Only if it touches a **different part** from the task under way, from every agent already running, and from every `[>]` or `[~]` task of another session (judge its part from its text and branch). Tasks in two different projects are always in different parts. Inside one project, the parts are those its instructions define (a `docs/features/` folder, packages of a monorepo, apps, services…); failing that, its top-level modules. Two requests on the same part never run at the same time.
4. **Orchestrate** what passes the triage as suits the work: there is no fixed limit on agents. One agent per task by default; small related tasks on the same part can share one agent and one PR only if the user grouped them; a task that depends on another waits for it (see *Stacked work*). For each: mark it handed to its agent first — if the task was taken meanwhile, start nothing — then call the `Agent` tool (`run_in_background: true`, a short meaningful `description`, and `name` where the tool has one, plus the task's `model` and `effort` if it has any) with the brief below. For the current project use `isolation: "worktree"`. What does not pass stays pending.
5. Answer in **one line**: "Noted in <project> (N pending, M in parallel)." or "Noted in <project>, started in parallel (agent <name>, sonnet · medium)." — several projects: "Noted: 2 in api, 1 in web (agent web-footer)." — a blocked one: add its question. Name the run options only when the task has some. No further analysis.
6. **Resume the task under way** unchanged, unless the new request directly contradicts it (say so in one sentence and follow the most recent request). Nothing under way: the first request that is neither blocked nor handed off becomes your task, as in *When your own task is done*, step 2.

### Brief for a parallel agent

It knows only what you write. Give it:
- the user's exact request, word for word, with its notes;
- the project (absolute path of its checkout) and the part concerned, with the files to read first: the project's `CLAUDE.md` / `AGENTS.md` (root and in the folder it works in) and the part's own doc if the project has one;
- where to work, never in a checkout the main conversation uses. Current project: it is already in a worktree of its own, so no second one: `git fetch origin <default>`, then `git switch -c claude/<short topic> origin/<default>`. Another project: `git -C <project> fetch origin <default>`, then `git -C <project> worktree add <scratch dir>/<branch> -b claude/<short topic> origin/<default>`. `<default>` is the default branch (`todo.sh -C <project> default`);
- the rules: do the task completely, tests included; update the project's docs as its instructions require; run the project's check command (from its instructions, else its `package.json` scripts, `Makefile`, CI config…) until green; commit, push **its own branch** and **open the PR** with `gh` or the GitHub tool it has — **never merge it, never push to the default branch, never deploy**; never touch the to-do queue;
- if it cannot open the PR: push the branch and say so, you will open it;
- if it hits a choice that belongs to the user: do not decide, push what is done, and say so in its report;
- its final report, short: the PR's URL, its branch and worktree path, what changed, what it could not do, any questions.

## When an agent reports back

Between two steps of your own task:
1. PR open: mark the task done with the PR's URL, and list the PR in your next report. Branch pushed but no PR: open it yourself, then the same.
2. It raised a question: mark the task blocked with it, and ask the user in your next report.
3. It failed with nothing usable: release the task, with a note saying what happened and its branch if any. Do not start the same task again by yourself more than once.
4. Remove its worktree once its branch is pushed (`git -C <project> worktree remove <path>`), never one that holds unpushed work.
5. Rerun the triage on the pending tasks of every project, in queue order.

Its branch started from an up-to-date default branch: do not rebase it now. Rebasing belongs to merging.

## When your own task is done

1. A task from the queue: open its PR, then mark it done with the PR's URL; if it changed no code, done with `no PR: <result in a few words>`. A task the user gave outside `/todo` ends as they asked: the skill opens no PR for it.
2. Read the queue and take the first pending task that does not touch a part handed to an agent or held by another session — in the current project first, then in the others. Claim it: if it was taken meanwhile, take the next. Announce it in one line ("Next (<project>): … (N left)") and start it right away, without waiting for confirmation, on a new branch `claude/<short topic>` from an up-to-date `origin/<default>` — never on top of the branch of the task you just finished, unless *Stacked work* applies. A task with run options goes to an agent instead, and you take the next one. Before that, rerun the triage: other tasks may start in parallel.
3. A request too ambiguous to do safely: mark it blocked with the question, and move on to the next one. Ask all the open questions at the end. When the user answers one, in the conversation or on the page: release the task with their answer as a note (the page does it itself), and triage it like a new request.
4. Queue empty and no agent running: say so in one line in the final report, with the PRs left open for the user.

## Stacked work

Nothing is merged without the user, so a finished task's changes are not on the default branch yet. A task that needs them, or that touches the same part as a PR of the queue that is still open, starts **from that PR's branch**, and its own PR targets that branch. Write "Stacked on <PR URL>" at the top of its PR body, add the note "stacked on <PR URL>" to the task, and tell the user two things: to merge in that order, and to delete each branch as it is merged, so that the next PR is retargeted to the default branch instead of being merged into a dead branch.

## Merging and deploying

**Never**, unless the user explicitly asks — in the conversation, or in a project's instructions (`CLAUDE.md`, `AGENTS.md`) that say the work is merged or deployed without asking. A task of the queue is never such a request: one that asks for a merge or a deployment is blocked until the user confirms it in the conversation. A request to merge covers the PRs it names, nothing more. When merging, go **one PR at a time per project**: rebase on `origin/<default>`, rerun the check, push the branch with `--force-with-lease`, merge, then deploy only if that was asked too (two deployments at once can put an older default branch back in production). Then mark the task merged.

## Rules

- The queue is changed only by the main conversation, and by the user on its page. It is never written into a repository.
- A pending request never justifies interrupting, shortening or half-finishing the task under way.
- Each request is a separate task: its own branch, its own PR — unless the user grouped them.
Pliki w paczce (3)
  • SKILL.md 18 KB
  • page/todo-queue.html 17 KB
  • scripts/todo.sh 13 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · alexisjamet/todo-skill100MIT
markusleben/ha-nova100MIT
guangshinhaha/shinstack100MIT
wangjs-jacky/jacky-skills100MIT
sejas/ai-code-skills100MIT
noahdunnagan/cafe100MIT
postmelee/hyper-waterfall100MIT
lnmunhoz/agent-ready-repo96MIT
Cruna-Noise-To-Signal/cruna-plugins90Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 5803e5aa0467 (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

  • 100tasks
    Obsługuje listy zadań w plikach .llm/todo.md: wyciąga niezakończone pozycje, oznacza je jako zrobione i realizuje zadania.
  • 100todo-create
    Zapisuje w pliku zadania do wykonania i ustalenia z różnych sesji, pilnując ich statusu.
  • 90todo-enqueue
    Dodaje kartę do ToDo projektu z bieżącej sesji wraz z treścią, typem, priorytetem i otwartymi pytaniami użytkownika.
  • 100triage-todo
    Przetwarza pozycje z plików .todo i .todo-inbox, zamieniając je w kamienie milowe, plany, zadania, cięcia zakresu lub skreślenia.
  • 100init-tasks
    Zakłada system śledzenia zadań z plikami todo, lessons i retro oraz katalogiem zmian, jako standard zarządzania projektem.
  • 90standing-orders
    Zapisuje wpis w pliku .todo repozytorium, żeby praca przechodziła między sesjami, bez pytania użytkownika o zgodę.

Uwagi i zgłoszenia

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