task
/task
Manage the project task backlog as plain markdown files in tasks/. Use when the user asks to list or query existing tasks, to update or expand one, to triage or split backlog items, or to work across several tasks at once, and as the fallback for any tasks, todos, or backlog request naming no single lifecycle step. Not for one named step on one task, which a sibling owns for creation, readiness checking, explanation, next-work selection, implementation, audit, and finish.
- Author
- theafh ↗
- Repository
- ai-modules ↗
- Licence
- MIT
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 4
- Scripts
- 3
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 3 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/discover_tasks.sh, scripts/init_tasks.sh, scripts/lint.py
What it does and when to use it
Manage the project task backlog as plain markdown files in tasks/. Use when the user asks to list or query existing tasks, to update or expand one, to triage or split backlog items, or to work across several tasks at once, and as the fallback for any tasks, todos, or backlog request naming no single lifecycle step. Not for one named step on one task, which a sibling owns for creation, readiness checking, explanation, next-work selection, implementation, audit, and finish.
Original author description
Manage the project task backlog as plain markdown files in tasks/. Use when the user asks to list or query existing tasks, to update or expand one, to triage or split backlog items, or to work across several tasks at once, and as the fallback for any tasks, todos, or backlog request naming no single lifecycle step. Not for one named step on one task, which a sibling owns for creation, readiness checking, explanation, next-work selection, implementation, audit, and finish.
How it works
SKILL.md has no level-two headings · 492 lines, 15,435 words
SKILL.md preview
---
name: task
description: Manage the project task backlog as plain markdown files in tasks/. Use when the user asks to list or query existing tasks, to update or expand one, to triage or split backlog items, or to work across several tasks at once, and as the fallback for any tasks, todos, or backlog request naming no single lifecycle step. Not for one named step on one task, which a sibling owns for creation, readiness checking, explanation, next-work selection, implementation, audit, and finish.
version: 1.3.49
author: Andreas F. Hoffmann
license: MIT
---
# task
<task_skill>
<role>
The task skill is the hub and source of truth of the `task_*` family: the **project-local backlog** that manages a project's upcoming work and todos as plain-markdown task files living next to the code. The concept behind the whole system: every task file is written to be **self-sufficient**. The file alone is enough to implement the work from, including in a later session with no memory of the task's creation. That sufficiency is a floor, never a filter: at implementation time the implementer draws on everything actually available, namely the codebase, the project's standing-instruction baseline, and the user in the loop.
</role>
<when_to_activate>
Activate this skill when the user:
- Asks to create, write, capture, file, or add a task / todo / backlog item.
- Asks to list, show, find, or query existing tasks.
- Asks to update, edit, refine, or expand a task.
- Says a task is done, finished, implemented, shipped, or completed: move it to archive with status `finished`.
- Says a task should be dropped, parked, deferred, or shelved: move it to archive with status `deferred`.
- Asks to lint, audit, or health-check the tasks directory.
- Mentions the project's tasks, todos, or backlog in any way that implies persisting upcoming work as files rather than chat state.
</when_to_activate>
<not_in_scope>
The wiki skill captures durable knowledge (concepts, procedures, references). The task skill captures *upcoming work* on this project. When a user message is about recording what they learned or how something works, route to `wiki` instead. When they want to track what still needs doing, this skill is right.
A focused sibling serves some of that backlog work better than the hub does. When a request names one task and one lifecycle step (check this task, implement it, audit it, close it out), hand it to the sibling that owns that step, which `<family>` names alongside every other sibling's role. Broad and multi-task backlog work stays with the hub: listing and querying the tree, triaging or updating several tasks in one round, and mining one source into a set of tasks, except where `<family>` names a sibling that owns that whole-tree job. The preference routes a request to the narrower surface rather than withholding it, since the hub keeps every capability `<family>` opens by stating.
</not_in_scope>
<architecture>
```text
<project-root>/
├── CLAUDE.md? # optional harness-loaded project rule file
├── AGENTS.md? # optional harness-loaded project rule file
├── GEMINI.md? # optional harness-loaded project rule file
├── CHARTER.md? # optional family-consulted hard project-purpose guardrail
├── ARCHITECTURE.md? # optional family-consulted descriptive project architecture
├── FEATURES.md? # optional family-consulted behaviour ledger
├── TESTING.md? # optional family-consulted project-specific testing notes
└── tasks/
├── <scope>_<name>.md # open tasks
├── <scope>_<name>.md
└── archive/
├── <scope>_<name>.md # finished + deferred tasks
└── <scope>_<name>.md
```
The filing convention has one canonical split: material directly about the task system lives under `tasks/`, and project-wide standing material lives at the repo root as optional `UPPERCASE.md` docs. Two root-doc roles exist there: harness-loaded rule files (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md` and equivalents) provide the project's standing-instruction baseline, while family-consulted guardrail docs (`CHARTER.md` / `ARCHITECTURE.md` / `FEATURES.md` / `TESTING.md`) add task-family-specific constraints and context. The task tree stays intentionally two layers: `tasks/` for live work and `tasks/archive/` for closed work. No further task nesting. Scope sits in the filename, not in a folder. A bare project with only `tasks/` remains complete.
</architecture>
<standing_doc_consumption>
Resolve the project root from the base `<discover>` step. The project's standing instructions start with the harness-loaded root rule files: `CLAUDE.md` / `AGENTS.md` / `GEMINI.md` and equivalents. When present, the harness loads those files before the skill runs, and the task family follows that baseline at every touchpoint independent of whether any family guardrail doc exists. The task family adds no separate presence-gated read for those harness files because the harness already supplies them.
Family-consulted guardrail docs are the additive layer over that baseline. Gate each optional family guardrail doc read with POSIX `test -f "$root/<DOC>.md"`. On a hit, the consuming skill or agent reads the doc for the purpose named at its touchpoint; on a miss, it continues unchanged and raises no missing-doc error.
`CHARTER.md` is the highest-order guardrail: any skill or agent about to write or change task content validates the proposed content against the charter's boundaries and invariants and stops on a violation. The harness baseline governs wherever the family guardrail docs are silent. When a harness rule conflicts with a softer guardrail doc (`ARCHITECTURE.md` / `FEATURES.md` / `TESTING.md`), surface the conflict for human review instead of auto-resolving it. Before relying on this ranking, or on a softer doc's advisory role, to settle a task fork whose paths cross guardrail boundaries, apply the **Guardrail-bound ground.** paragraph of the `<body>` **Decide or label** rule, which states what the ranking settles and what stays with the user. The softer docs inform work without blocking it: `FEATURES.md` and `ARCHITECTURE.md` provide prior-art and design context for task creation, `TESTING.md` provides project-specific testing details for implementation and audit, and `ARCHITECTURE.md` is refreshed during finish when completed work extends the design and the recorded `design-extended` signal is `true`.
</standing_doc_consumption>
<file_format>
<naming>
`<scope>_<name>.md`. One underscore, exactly one, separates scope from name. Inside each side, words use `-`. Both sides are lowercase `a-z 0-9 -`. Examples:
- `wiki-fix_split-page-anatomy.md`
- `tasks-skill_initial-implementation.md`
- `auth_session-token-rotation.md`
- `infra_grafana-dashboard-cleanup.md`
Pick `scope` from the project's natural shared groupings: a skill family, sub-project, module, topic, feature area, or service. Pick `name` to be compact, unique within the tasks tree (open *and* archive), and self-explanatory at a glance. Before creating, list the tasks directory and `archive/` once to confirm the chosen name does not collide.
</naming>
<frontmatter>
Every task carries this YAML frontmatter:
```yaml
---
description: "One-line compact summary of what this task delivers."
scope: plugins/ai_dev/skills/task
created: 2026-05-28T19:49:23
updated: 2026-05-28T19:49:23
status: open
reported-by: default_user
---
```
Fields:
- `description`: a compact one-liner written in double quotes. Escape any `"` or `\` inside the value with a backslash. Compose to roughly 180 characters; the linter warns above 200, and that gap is headroom for a later broadening edit rather than length to write at. The body carries the full context.
- `scope`: either a relative path under the project root pointing at the directory the task targets (unquoted; e.g. `scope: plugins/ai_dev/skills/task`), or a short descriptive label when no single directory fits (quoted; e.g. `scope: "project xyz"`). The linter resolves an unquoted value against the project root and blocks if the path is missing or escapes the root; a quoted value is accepted as text. Paths win when one fits; the filesystem stays the source of truth.
- `created`: ISO 8601 datetime, set once when the task is created.
- `updated`: ISO 8601 datetime, bumped on every edit and on every status change. See `<bump_updated>` for the legacy-backfill exception.
- `status`: one of:
- `open`: created and not yet checked.
- `checked`: `task_check` ran and found blocking issues, either directly or as the gate inside `task_auto_check`, or a family skill or agent rewrote a `ready` task in a way that changes what it delivers or how that delivery is checked, as `<status_discipline>` directs.
- `ready`: implementation-ready, either from a clean `task_check` verdict, from `task_auto_check` reaching that verdict, or from the user declaring readiness through the apply-findings update flow.
- `implemented`: `task_implement` built the work, or a re-audit of an `audited` task found gaps and re-opened it for `task_implement`.
- `audited`: `task_audit` confirmed every body item, acceptance check, and required test over a current `implemented` task.
- `finished`: closed out as done and archived.
- `deferred`: parked or dropped and archived.
- `reported-by`: the user who created the task, written by the create path and resolved via `<user_name_chain>`. See `<bump_updated>` for legacy backfill.
- `implemented-by`: the user who built the work, written by `task_implement` when it stamps `implemented`, required on `implemented`, `audited`, and `finished`, and resolved via `<user_name_chain>`. Deferred tasks omit it because they were never implemented. See `<bump_updated>` for legacy backfill.
- `design-extended`: boolean design signal, written by `task_implement` in the same stamp pass as `status: implemented` and `implemented-by`, then verified by `task_audit` and consumed by `task_finish`. Implement records the verdict explicitly on every stamp, writing `design-extended: true` when the delivered work passes the `<archive>` trigger test and `design-extended: false` when it does not, so a newly implemented task always states its assessment. The field is nonetheless **optional, and absence reads as `false`**: a task predating the field stays clean without it and needs no backfill, since the verdict is a code-level judgement no later stage can derive from git history or the task text. The linter enforces exactly that split: a present value must be `true` or `false`, and an absent one draws no finding.
Status matches location: `open`, `checked`, `ready`, `implemented`, and `audited` live in `tasks/`; `finished` and `deferred` live in `tasks/archive/`.
<user_name_chain>
Resolve a recorded user name by reading `git config user.name`; when that is empty or the project is not a git repo, ask the user which name to record; when the ask goes unanswered, write the literal string `default_user`.
</user_name_chain>
Obtain the timestamp by running the shell command below and copy its output verbatim, because the model has no clock and a hand-written time is a guess:
```bash
date +%Y-%m-%dT%H:%M:%S # local time, e.g. 2026-05-28T19:49:23
```
Both `created` (set once, on a fresh task) and `updated` (bumped on every edit, status change, and archive move) take their value from this command's output. When creating several tasks in one turn, run `date` once and reuse the captured value across the batch rather than re-running it per file.
</frontmatter>
<lifecycle_responsibility>
Each stage records the furthest lifecycle point it establishes: `task_create` writes `open`; `task_check` writes `ready` when no blocking finding remains under the `<readiness_checklist>` **Blocking bar** and `checked` when one does; `task_auto_check` edits the task body and reuses `task_check` for those `ready` / `checked` stamps; any family skill or agent whose rewrite of a `ready` task changes what the task delivers or how that delivery is checked writes `checked` in that edit, under `<status_discipline>`; the apply-findings update flow writes `ready` only when the user declares readiness before implementation; `task_implement` admits a build only under the ready-before-build rule (status is `ready`, or status is `implemented` and named gaps from a prior `task_audit` report are in context or supplied by the user), then writes `implemented` and records the `design-extended` verdict; `task_audit` writes `audited` only for a clean, complete verdict over a current `implemented`, writes `implemented` over `audited` when a re-audit finds gaps for `task_implement`, and verifies the `design-extended` signal, recorded or absent, against the built change; `task_finish` writes `finished` for done work or `deferred` for parked work.
</lifecycle_responsibility>
<backward_move_guard>
Before a stage writes a status, read the current status and compare it to the target. A write that moves an `implemented` or `audited` task to an earlier status, or that changes the status of a `finished` or `deferred` task at all, is a hard stop: the stage writes no status, leaves the file as it is, names the current→target move it refused, and routes the work as `<status_discipline>` directs for completed and archived tasks. One backward move stays open: the re-audit re-open, in which an `audited` task returns to `implemented` because a re-audit found gaps for `task_implement`, written by `task_audit` with its gap verdict or by the user through `<update>`. User confirmation opens no other backward move. The guard binds every writer. The ones it catches in practice are `task_check`, which would otherwise write `checked` or `ready` over a later status, `task_implement`, which would otherwise write `implemented` over `audited`, `finished`, or `deferred` and therefore reads the status before it builds anything, and an `<update>` in which the user asks for any other earlier status on completed or archived work. Forward moves, same-status stamps, the re-audit re-open, `task_check` revising its own `ready` to `checked`, the move from `ready` to `checked` that `<status_discipline>` prescribes for a rewrite, and parking a live task as `deferred` proceed without this guard.
</backward_move_guard>
<status_discipline>
**Status discipline.** This rule decides what a rewrite of a task body does to `status`, and it binds every skill and agent in the `task_*` family that edits a task body, whichever workflow or pass makes the edit. A task may be rewritten before implementation, and after implementation its status only moves forward. The effect of a rewrite depends on the status the task carries when the edit lands:
- **An `open` or `checked` task** keeps its status through any rewrite.
- **A `ready` task** returns to `checked` in the same edit only when the rewrite changes what the task delivers or how that delivery is checked, and the run's report then names the task and what changed. A change to `## Goal` always returns the task to `checked`. An Approach step or Acceptance item that the rewrite adds, changes, or removes returns the task to `checked` when it asks for work or a check the task did not already require, or drops work or a check the task required, and it keeps `ready` when it only makes an existing requirement explicit. A mechanical change to links never returns the task to `checked`, whether it re-points a link or turns a link into plain text, and neither does any other fix from the `<lint>` mechanically fixable lint finding set. Rewording that keeps the meaning, such as an anchor refreshed to the current name of the code it points at, a regroup under the `<lint>` **Repeated-link react protocol**, and a clarifying note keep `ready` as well.
- **An `implemented` or `audited` task** keeps its body as delivered. A family repair skill or agent reports a finding about it, routes the finding to `task_audit`, whose gap verdict sends the work back to `task_implement` on the same task, or to `task_finish`, and applies only mechanical link and lint fixes to the file. An edit the user explicitly asks for through `<update>` stays the user's call, and it leaves the status as it is.
- **A `finished` or `deferred` task** keeps its status for good, including when its file under `tasks/archive/` gets a mechanical rewrite such as a re-pointed link. Its body stays as delivered apart from mechanical link rewrites, so a family repair skill or agent reports a finding about it instead of applying the repair.
- **A task file a split creates** starts at `open`, whatever status its parent carried, because no gate verdict transfers to text the gate never read.
After implementation the status moves forward, from `implemented` to `audited` to `finished`, and a live task at any status may move to `deferred`. The one move back is the **re-audit re-open**: when a re-audit of an `audited` task finds gaps that `task_implement` should fix, the task returns to `implemented`, `task_implement` fixes those gaps on the same task, and the implement and audit loop repeats until a clean audit stamps `audited` again. `task_audit` writes that `implemented` with its gap verdict, and the user may ask for it through `<update>`. No skill or agent writes `open`, `checked`, or `ready` over an implemented or later status, or any status over `finished` or `deferred`, and user confirmation does not open those paths, because `<backward_move_guard>` stops every such write.
**Follow-up tasks.** Gaps in delivered work stay on the task that delivered it. A new follow-up task is filed only when the implement and audit loop stalls and keeps repeating the same findings, when a finding is a genuinely different issue with no real overlap with the delivered task, or when the gaps sit in an archived `finished` task, whose status is final.
Where this rule leaves a status standing, a contract-altering repair still earns a re-check flag **in the report**, naming the task and what changed: a rewrite of a `checked` task that alters its Goal, Approach, or Acceptance, and a contract-altering repair the pass surfaces without applying. Lowering a `ready` task to `open` to signal that re-check is owed is the failure this rule names: it destroys the readiness verdict `task_check` established, and no later stage can tell that demotion apart from a task that was never checked. Only `task_check`, `task_auto_check`, and the user's readiness declaration in `<update>`'s apply-findings flow write `ready`, and that declaration stamps `ready` on the edit that carries it.
</status_discipline>
<markdown_policy>
Task bodies are **100% CommonMark-standard markdown**. The YAML frontmatter at the top is the only allowed extension. The linter blocks on non-standard syntax so the tasks tree stays portable to any renderer and the filesystem stays the source of truth:
- **No footnotes.** `[^name]` references and `[^name]: …` definitions are non-standard. Place attribution inline as a normal markdown link next to the claim.
- **No wikilinks.** `[[target]]` is an Obsidian extension. Use `[text](relative-path.md)` for cross-references.
- **Local cross-references are standard markdown links.** On a default or `--include-archive` run the linter's link check covers every in-repo markdown link from every markdown file under the repository (any in-repo target, file or directory) and ignores every target that leaves the repository (`://`, `mailto:`, empty or fragment-only, or a path that resolves outside the repo root). Under `--file`, link checks stay scoped to the named task file alone. Broken in-repo targets block. The check skips links inside fenced code blocks, inline code, autolinks, and raw HTML, and it reads four-space-indented text as live content, because that text is usually list content. Put a code sample that carries an example link in a fenced block.
- **Link to another task file when the cross-reference carries weight.** Add a link when it marks a **dependency** (this task builds on, extends, or must follow the other), when reading the linked task would **change how this task is implemented** (it defines a rubric, format, or interface this task consumes), or when the **linked file will be co-edited** (a shared region, a coordinated double-edit, or competing mechanisms to reconcile). The settling test: would reading the linked task, or knowing it exists, change how you implement this task or edit this file? Keep the link when yes; leave out a relatedness-only reference, such as a bare "see also" / "distinct from" / "pairs with", or a reverse-duplicate pointer whose relationship the linked side already states, since reading the target changes nothing about the work.
- **Gather what the body says about one link target into one place: the grouping rule.** Let one link carry that group. The linter's `repeated-link` warn reports a target linked more than once anywhere in one body. When those links sit in more than one paragraph, the warn is a sign that material belonging together has spread across the body, and the author answers it by reorganizing the body until that material sits together under one link, as the `<lint>` **Repeated-link react protocol** describes. Where a paragraph already links a target, name it again inside that paragraph in plain text. That governs a repeat inside one paragraph, and it never licenses stripping the link from another section to bring a `repeated-link` count down. The two link rules divide the work: the cross-reference bullet above decides whether the body links a target at all, and the grouping rule decides how the body organizes what it says about a target it links.
- **Locate referenced content by a verbatim label: the soft-pointer rule.** Anchor every pointer to an exact, greppable string in the target (a heading, a pseudo-XML tag, a symbol or rule name, a list item's bold lead-in, or a short quoted phrase) together with the file path, so the reference resolves by search and fails loudly (grep finds nothing) once the target is reworded rather than landing the reader on stale, plausible-looking wrong code. The label carries the whole reference and must be verbatim-greppable: a vague description like "the matchers block" does not qualify. Give extent, when useful, as size ("the ~10-line guard block"), never as position. Keep position claims out: a `:N` suffix on a file path, a bare `line N`, an `around lines N–M` range, and an ordinal list-position reference such as "step 6", "item 3", or "the second bullet" all locate by a position that rots silently as the target evolves. When the referencing task inserts, removes, or reorders items in the target list, anchor to the item's own verbatim label rather than to its ordinal position.
- **Reference a mutable set by its defining property: the count-stable rule.** Refer to a set whose membership can change by the selector that picks it out: a filename glob, a greppable label, or a phrase such as "every live `task-family_*` task" or "each check registered in the lint runner". Name a load-bearing quantity by the derivation that yields it at implementation time (the command or the source that produces the number) in place of freezing the number in prose ("all N live `task-family_*` tasks") or freezing an enumeration snapshot of the set's current members. The settling test: the reference stays true when set membership changes between writing and implementation, which a selector and a derivation survive and a frozen number does not. Work and proof over such a set take the same shape: the Approach finds the members by the selector at implementation time and applies the change to every member found, and the Acceptance item runs the selector again and checks that no member is left unhandled, rather than checking that a fixed number of members changed. A quantity that is subject matter rather than a set reference stays as written: a measurement protocol's run count and fixed denominator under the `<body>` **Measured, with a fail branch** acceptance clause, a size extent the soft-pointer rule already endorses ("Give extent, when useful, as size"), a number that is itself the artifact under edit, and a count carried only as a quoted or illustrative example of the shape this rule replaces.
Simplicity, single-topic scope, and standard tooling beat every non-standard extension.
</markdown_policy>
<body>
The body starts with a single `# Title` H1 on the first non-blank line, followed by the rest of the task content. Write the body to be **self-sufficient**: the file carries everything the work needs that the project itself does not already hold, while whatever exists at implementation time (the codebase, the project's standing-instruction baseline, the user in the loop) stays in play and gets used. Self-sufficiency is what lets a task outlive its origins: the conversation that created it is the one context guaranteed to be gone by then. Corollary: content a standing project instruction (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md` and equivalents, plus the applicable family guardrail docs) already mandates is cited from the task as a standing repo rule, with the rule's text staying in its source document. Fill these sections:
- **Goal**: what the task delivers and the user-visible outcome.
- **Context**: pointers to the relevant files, modules, prior decisions, related tasks, links.
- **Approach**: the intended implementation path and any constraints, plus the task's declared exclusions when it has them, carried in the single `**Out of scope:**` block the **Declare exclusions as an Out of scope boundary** rule defines.
- **Acceptance**: the contract of concrete checks that say the task is done (a staged fixture the new behaviour is proven on, a file state to inspect, a measurement recorded in a named tree artifact per **Deliverable items flip.**). Every item honours the contract:
- **Deliverable items flip.** Each item is false today and flipped true by the work, verifiable mechanically against the working tree as it stands before any commit. Its proof surface is a tree artifact: a command's output from that tree, a file state, a fixture, a test, or a results or notes file prepared for commit. The commit message and the pull-request description are never proof surfaces.
- **Edit items supersede the stale passage.** When the task changes an existing artifact, at least one item checks that the prior passage is superseded and one canonical statement remains, rather than only checking that the new content appears somewhere.
- **Task-specific gates only.** Every item's outcome changes with this task's work. The project's standing instructions own the generic gates (`make lint`, a deploy dry-run, the full test suite), which run at their standing moments; name a gate only when the task changes what it verifies, such as a new lint rule proven on a staged fixture or a new scenario added to a suite.
- **Implementer-runnable.** Every item verifies through steps the implementer runs alone; an action the project's standing instructions gate on the user stays out of acceptance.
- **Measured, with a fail branch.** Stochastic or empirical work names its measurement protocol (run count, fixed denominator, baseline) and the tree artifact that holds its recorded measurement, per **Deliverable items flip.** When the work delivers the number itself, the recorded measurement is the deliverable. The item states what happens when the hypothesis fails rather than gating on the hoped-for direction.
- **Enumerate.** Prefer a list of independently verifiable items over one compound check.
- **Sets by selector.** An item over a set whose membership can change re-finds the members by their selector and checks every member found, in the shape the `<markdown_policy>` count-stable rule defines, so done never rests on a count frozen at writing time.
Write the body positive and action-oriented: the primary carrier of every section is what the work does. Goal, Approach, and Acceptance lead with the action taken and what "done" looks like. Negatives earn their place where they carry content of their own: a genuine out-of-scope entry, a guardrail the task delivers, or the task-specific gate the **Acceptance** contract defines. Keep rejected-option debate out of the body: a brief out-of-scope entry or guardrail stays, while the rationale for options weighed and rejected lives in the change's commit or pull-request description, or in the wiki when it is durable design knowledge. Frame the body as current state to target (what exists, what is not there yet, and the state the work reaches), and let **Rewrite in place, don't append** define the target when an existing passage is affected.
Further rules govern the body's structure:
- **State once.** Each rule, constraint, or decision appears in exactly one place in the body; Goal, Approach, and Acceptance point at that statement rather than re-wording it, so the sections stay in agreement as the task evolves.
- **Decide or label.** On any open decision a task carries (an unresolved fork, a vague pointer, an either/or left undecided), first reconcile, else surface, and expect reconcile to be the answer. **Reconcile** by settling the decision to the single path that best fits the task's spirit, drawn from an ordered evidence base: (a) the task's own stated intent across its Goal, Approach, Acceptance, and description; (b) the standing repo rules, comprising the harness-loaded rule files and the guardrail docs where present, consulted through `<standing_doc_consumption>`, with `CHARTER.md` the hard boundary and `ARCHITECTURE.md`, `FEATURES.md`, and `TESTING.md` subordinate; (c) the working session's own context at stages that run inside one; (d) related and older tasks, both linked live siblings and archived precedent; (e) the project's in-repo wiki where present; (f) the already-implemented codebase. Walk those tiers before calling anything open: a fork any tier settles is reconciled silently rather than surfaced, with a stage that can write recording the resolution in the body and a read-only stage recommending it. The **decisive-default test** catches the standard masquerade: a default the author can name and justify from that evidence base, with no tier against it, is already a reconciliation, so adopt it and record it instead of labeling it. **Surface** only a decision that passes the **why-open test**: the labeled "Open decision:" states in one clause why this fork is genuinely open, and exactly two grounds qualify. One is that the evidence is **insufficient**: the tiers are silent, or they conflict and none of them resolves that conflict, which covers a call resting on user preference the evidence cannot reach, such as taste, priority, cost, or risk appetite. The other is a guardrail-bound fork, which the **Guardrail-bound ground.** paragraph below defines. When that clause cannot be written truthfully, the decision is reconcilable and the Reconcile branch applies. A qualifying decision is then handled twice over, and both halves are mandatory: it is written into the body as the labeled "Open decision:" carrying its options, a suggested default, and the why-open clause, and it is surfaced to the user, at authoring time through the create path's **Offer open-decision reconciliation** step, and at the non-interactive stages through `task_auto_check`'s human-routed stuck channel and `task_implement`'s instruction to "surface the decision to the user with its options and at least one suggested path and hold". A label the user never saw, and an ask that left no trace in the file, each violate this rule. The label's default is therefore a suggestion among evidence-equal options, or a starting point for a user-owned call, rather than the settled path the decisive-default test already claims. Zero labeled open decisions is the expected authoring outcome and one is the ceiling: reaching it is the exception the why-open clause justifies, because every other fork was reconciled from the material available while writing. Each stage that meets an open decision applies this one procedure at its own point in the lifecycle.
**Guardrail-bound ground.** A fork is guardrail-bound when every path in play crosses a guardrail boundary, meaning a boundary or rule that `CHARTER.md`, a softer guardrail doc, or a harness-loaded rule file states. A path crosses a boundary when it breaks the rule, when it rewrites the guardrail document so the rule no longer stands in its way, or when it routes around the rule by keeping its wording while setting aside what it protects, as when a forbidden construct moves into a dedicated module. The guardrail ranking in `<standing_doc_consumption>` settles which constraint wins in the abstract, so a softer doc that conflicts with the charter yields to the charter, and the label's suggested default may lean on that ranking. Choosing the path stays a user-owned fork: rewriting the outranked guardrail document or routing around its rule changes a rule the user set, so the user decides it. When the tier (b) walk finds every path crossing a boundary, stop reconciling and handle the fork under this ground, because the ranking leaves a guardrail tier against every default and so no default passes the decisive-default test. Write the labeled "Open decision:" naming each path and the boundary it crosses, give this ground as its why-open clause, surface it to the user through the dual obligation above, and leave the choice of path to the user's answer. A fork with at least one path that crosses no boundary goes to the Reconcile branch like any other.
- **Illustrate.** The general statement carries each rule or requirement; specific cases, incident histories, and dated references stay brief illustrations supporting it. An illustration earns its place only by supporting a rule or requirement the body already states; incident narrative with nothing to illustrate (how a fact was established, why an earlier attempt failed, what changed since a prior version) carries nothing an implementer needs and stays out, however accurate. A body whose meaning lives only in an example has its altitude inverted.
- **Redact by generalizing.** Keep user-specific and sensitive detail out by default: generalize rather than embedding absolute or home filesystem paths, secrets and credentials, personally identifiable data, and incidental product, project, tool, or person names. Repo-specific detail enters only when the user explicitly asks for it or the work genuinely needs it, and the body surfaces that choice rather than adding it silently.
- **Compact only to the implementable floor.** Write compactly while a one-shot implementer can still act without re-deriving dropped detail. Stop compression when it would stack clauses until the logic between them is lost, name an edit site without the shape of the change, or give a rule without the one example that fixes its meaning. Test the floor with this question: would this file, plus the project, let an implementer produce the intended change without filling a gap from outside?
- **Rewrite in place, don't append.** When a task changes an existing artifact, frame the work as rewriting the affected passage in place to its target form, naming the passage that exists and what it becomes. Default to rewrite or supersede the existing passage so one canonical statement remains. Use a genuine-addition framing where no existing counterpart exists, the surface is append-only by design (a changelog, activity or decision log, or commit message), a comment or design note carries load-bearing evolution, or two similar-looking rules cover genuinely distinct situations and both belong.
- **Declare exclusions as an Out of scope boundary.** The `**Out of scope:**` block records the work this task does not do. Declaring exclusions is optional; a task with nothing to exclude carries no such block. When a task does declare them, they live in one place: a single block inside `## Approach` led by the verbatim label `**Out of scope:**`, one statement per exclusion. Each entry is one of two kinds. A **rejection** stands alone: work this task never does, which the positive, action-oriented authoring rule already lets a task state directly, optionally citing the standing repo rule or `CHARTER.md` boundary that motivates it. A **deferral** names its owner: work recognized but pushed out of this task names the sibling task that owns it, carrying the link per the `<markdown_policy>` cross-link discipline when the entry holds the body's account of that sibling, and naming the owner in plain text when the grouping rule gathers that account elsewhere in the body. Either way the deferral keeps the implementable detail in that owner and stays a one-line pointer; the pointer marks ownership, never ordering, and imposes no prerequisite on either side. Scope trimmed from a task at creation, update, or repair lands as a deferral naming its owner or as an explicit rejection, never as a silent drop. Two tests bound what the block holds. The **requirement test** reads each entry's subject: when the task does work to make that subject true, it is a requirement and belongs in `## Goal`, `## Approach`, or `## Acceptance`, so every entry keeps work this task leaves undone as its subject. A rejection stays a rejection when it names the in-scope counterpart that fixes the exclusion's meaning ("a `--yaml` flag, since JSON is the only format this task adds"), because its subject remains the excluded work. The **waiver test**: an entry removes work from the task, never a rule from the work that remains, so every standing repo rule, guardrail-doc boundary, and project gate governing whatever does get built keeps applying untouched; an entry tracking a carve-out its governing rule already provides stays legitimate, since it narrows work the rule itself leaves out. Three cases therefore stay out of the block: an entry whose subject is a requirement, guardrail, invariant, or feature behavior the task builds, which belongs as a positive requirement in its own section; a note asserting that something is not excluded, whose in-scope item goes where it belongs and leaves the block to exclusions alone; and an entry exempting the task's own work from a standing repo rule, a guardrail-doc boundary, or a project gate, which is a decision the user owns and routes through **Decide or label** as a surfaced labeled decision rather than a self-granted exclusion. Existing tasks converge on this form opportunistically as they pass through update, check, and auto-repair; the convention mandates no migration sweep.
Keep each task scoped to **one** atomic item. Size by cohesion when one change spans many parts of one system: if the work shares one rationale, one edit surface, and one acceptance story, keep it one task even when part count is high. When atomicity and part count pull apart, cohesion decides; the **300-line** ceiling still wins. Split independent items, expandable tangents, and tasks that grow past **300 lines** into siblings before continuing.
</body>
</file_format>
<dependency_signals>
The family's single definition of when one task is a prerequisite of another and how that relationship is read from the backlog. The single-task front ends inherit this block rather than each carrying a copy: `task_select` uses it to sequence candidates during ranking, and `task_implement` uses it to gate a build behind unbuilt prerequisites. The relationships stay inferred from existing task content; no frontmatter dependency field exists.
A **prerequisite** is a live eligible task (frontmatter status `open`, `checked`, or `ready`) that is not yet done and must ship before the task depending on it. A relationship pointing at an `implemented`, `audited`, `finished`, `deferred`, or archived task is already satisfied and imposes no order.
Read the relationship from four signals already present in the task data:
- **Explicit ordering prose**: a task body names the order in words such as `depends on`, `blocked by`, `must follow`, `after`, or a companion reference naming another task file.
- **Dependency cross-links**: a task-to-task markdown link that marks a dependency under the `<markdown_policy>` **Link to another task file when the cross-reference carries weight** rule, rather than a relatedness-only "see also".
- **Forward references**: a task names a block, section, rule, symbol, or artefact that another task is the one to create.
- **Shared-surface collisions**: two tasks edit the same file or surface.
A relationship runs in **both directions**. A task is a prerequisite either by its own outbound signal (its body names what it waits on) or by another live task's inbound declaration (another live task's body names a first-ship order over it or forward-references an artefact it creates). Read both directions: a task silent about its own ordering can still be blocked by an inbound note authored in another live task, including one outside a user-applied scope filter.
Split the relationship strength two ways:
- A **hard ordering dependency** sets a required build order. It holds when a task forward-references an artefact another task creates, when explicit prose names the required order, or when a shared-surface collision carries **directional evidence**: one task creates, renames, removes, or rewrites a specific block, symbol, rule, or file state that the other task consumes.
- A **soft companion relationship** carries no required order but is worth surfacing: a coherence or cross-reference tie, or a shared surface without directional evidence.
</dependency_signals>
<readiness_checklist>
The readiness lens for one task file, judged against the self-sufficiency bar `<body>` defines. It lives here as the family's single source: judge a draft against it before writing the file, and judge an existing task against it before handing it to an implementer.
**Blocking bar.** Class every finding this checklist surfaces as blocking or as a note; only a blocking finding keeps a task from `ready`. A finding is blocking when an implementer who follows the task literally, drawing on the codebase and the standing repo rules, would do one of four things: violate the Goal or an Acceptance item, hit a contradiction, face an open choice whose reasonable options lead to materially different results, or introduce a new bug. Four classes block by definition: a **Charter check** conflict, a **Structural check** gap, and an invalidated **Premise check** outcome, as their own items below state, and a mutable set referenced by a frozen count or an enumeration snapshot under the `<markdown_policy>` count-stable rule, because that reference goes stale silently between writing and implementation even when it is accurate today. Every other finding is a note, because the implementer would most likely get it right anyway: redundancy, length, wording, ordering, a passage that reads harder than it needs to, or an unproven minor promise. Test a borderline finding by naming the concrete wrong result the literal implementer would produce; a finding with no nameable wrong result is a note. Report notes beside the blocking findings, keep them out of every repair loop, and never let them block `ready`. Every lens below feeds this one bar, so a lens names what to look for and the bar decides whether it blocks.
1. **Charter check.** When `CHARTER.md` exists at the project root, validate the task content against its boundaries and invariants. Surface every conflict as a readiness issue, leave the task body unchanged, and keep the task out of `ready` until the conflict is resolved.
2. **Structural check.** Confirm the body opens with a single `# Title` and carries the `## Goal` / `## Context` / `## Approach` / `## Acceptance` sections, with valid frontmatter, per `<body>` and `<file_format>`. A one-shot implementer follows structure literally, so a structural gap is high-severity; run this before the content lens.
3. **Premise check.** Every task body frames current state to target, so verify the described current state against the codebase as it stands now: read the code the task implicates, run the reproducing command when the task names one, and confirm a claimed gap is actually absent rather than already covered. Judge cited details from a written juxtaposition: quote each command, flag, path, and passage the task describes beside the code's actual text, and clear a detail only when the pair matches: a description that drops a flag, renames a path, or paraphrases a directive away is a drifted detail even when the cited anchor exists. Two staleness outcomes exist, and the finding names which one it is. **Invalidated** means the code contradicts the task's reason to exist: the defect already fixed, the capability already present, the need met by a mechanism that shipped since, the target artifact removed, the behaviour misdiagnosed. This is a readiness issue that invalidates the task before any other finding, and it opens a disposition that belongs to the user: closing the task `deferred` through `task_finish` or the `<archive>` workflow is one honest option beside re-scoping the intent or refuting the finding with evidence; a checking or repairing surface presents these options and never applies one itself. **Drifted** means the motivation still holds while described details have moved on: files renamed or relocated, cited passages reworded, part of the work meanwhile shipped. Each drifted detail is an ordinary readiness issue whose repair refreshes the body against the current codebase.
4. **Approach fitness.** Judge the Approach against the code it changes: followed as written, it must deliver the Goal and, when a bug or gap motivates the task, close the described gap completely. Flag an approach that treats a symptom while the named cause stays live, closes only part of the gap, or carries a gap of its own (a missed edit site, an unhandled case, a side effect that breaks adjacent behaviour). Ground the missed-edit-site check in a written enumeration: list the standing directives, invariants, and hard rules in the artifacts the approach touches that interact with the new behaviour, and clear each one against that behaviour: a directive the change would violate, or must amend to stay consistent, is a missed edit site even when every anchor the task names checks out.
5. **Interaction scan.** The code-anchored mirror of the two task-anchored lenses above, standing beside them as its own lens rather than folding into either: instead of starting from what the task describes, start from the task's change and ask what in the codebase now interacts with it that the task never accounts for. The motivating case is a task written before some feature shipped, whose change would now collide with, or be quietly undermined by, code that landed since, with nothing in the task pointing at it. Run a bounded two-step scan keyed on the task's change (derive its interaction surface, then search the repository over that surface) and classify and route each result:
- **Derive the interaction surface.** Read what the task links and names (its `scope`, the files cited in Context and Approach) and derive the concrete touch-points its change would create, rename, remove, or consume: symbols, function and type names, config keys, rule or tag names, file states, and behaviours.
- **Search the repository, read the hits, and classify.** Search the repository for references to those touch-points with whatever repository search tools are available, reaching callers, consumers, alternate definitions, tests, and docs the task never linked, and read the hits; for a hard-interaction hit (code that writes or reads the same state, or that the change would break or be broken by), follow one hop to its own references. Classify each result as a **contradiction** (code the task's change would break, or that would break the change) or an **unattended interaction** (shipped behaviour, an invariant, or a feature the task should account for but never mentions).
- **Hold the scan boundary.** Reach the whole repository through the touch-point search, yet read only the hits it returns plus the one hop for hard-interaction sites. Searching the whole repo for the task's touch-points is not reading the whole repo. This is none of a full-repo read, a scan limited to the task's linked files, or a recursive expansion that follows references of references to a fixed point, whose deeper transitive reach is not worth its unbounded cost. Name the search capability generically rather than pinning a specific tool, so the lens stays portable across harnesses.
- **Route the disposition through Decide or label.** Treat a confirmed finding as a readiness issue, grounded the way this checklist already requires (a written juxtaposition of the interacting code against the task's change), so an unverified suspicion stays a question rather than a numbered issue. Send its disposition through **Decide or label** rather than a parallel one: reconcile the conflict against the found code when that evidence settles the fix, else surface it with its options and at least one suggested path. This lens supplies the detection; **Decide or label** supplies the disposition.
6. **Content lens.** Read the task thoroughly and surface every issue that could derail a correct, complete one-shot implementation:
- **Scope sizing**: the most compact scope that still delivers a coherent, independently testable unit. Judge cohesion as well as size: shared rationale, shared edit surface, and one acceptance story favor one task; independent items, duplicated rationale, or 300-line risk favor splitting. Flag too-large (multi-pass risk, past the 300-line split) and too-small (coordination overhead, no standalone capability).
- **Focus**: one atomic item. Flag scope creep that belongs in a sibling task and should be cross-linked rather than folded in.
- **Complexity**: implementable in a single pass. Flag hidden multi-step or cross-cutting work.
- **Contradictions**: internal consistency, including behavioural contradictions where one part makes another non-functional; paraphrase drift between sections (what the **State once** rule prevents) is the standard source. The task's own declared boundary is in scope here too: a Goal, Approach, or Acceptance element that requires, delivers, or proves work the task's `**Out of scope:**` block excludes is a contradiction finding, and an entry readable as either a rejection or a deferral (so an implementer cannot tell whether the work is dropped or owned elsewhere) is a finding on the same rank. The reverse direction ranks the same: an `**Out of scope:**` entry whose subject is a requirement, guardrail, invariant, or feature behavior the task builds contradicts the block's purpose under **Declare exclusions as an Out of scope boundary**, and its fix relocates the item to `## Goal`, `## Approach`, or `## Acceptance`; a meta note asserting that something is not excluded is a note under the **Blocking bar**, because the literal implementer builds the in-scope item either way, and its suggested fix states the in-scope item where it belongs and drops the note. Judge by that rule's requirement test rather than by wording, so a rejection naming the in-scope counterpart that fixes its meaning draws no finding. Route a confirmed boundary finding's disposition through **Decide or label** rather than defining a new one: reconcile against the evidence when it settles which side wins, else surface with options.
- **Acceptance coverage**: the Acceptance proof set matches the promise set the body makes. Gather the promise set from the whole body: the body's explicit enumerations (validation rules, test cases, handled inputs) and every further commitment the description, Goal, and Approach make, including one carried by a subordinate clause, a parenthetical, or an alternative branch such as a named default or fallback. Pair the promises explicitly: write each promised item beside the Acceptance entry that proves it and give each row a binary verdict, where a promise whose row names its proving entry is paired and a qualified judgement such as weakly, partially, or indirectly paired is an unpaired row. Flag every unpaired item, and judge coverage from that written pairing rather than a prose impression that the sections map cleanly. An unpaired promise that carries a deliverable or a Goal outcome blocks even when an implementer following the body would still build the unproven piece, because an Acceptance short of the deliverables defines done short of the work; an unproven minor promise is a note under the **Blocking bar**. Trace each proof mechanism the Acceptance names (a fixture, a script, a command, a harness pattern) one level past confirming the referenced pattern exists: establish when it runs and what it can observe, and confirm it can produce the evidence its entry needs; a mechanism that runs at the wrong time or observes the wrong surface leaves its promise unproven, on the same rank as an unpaired promise. Keep this distinct from **Contradictions**, which checks consistency rather than completeness of proof.
- **Title/description coverage**: the H1 title and frontmatter `description` name the deliverable set the body now carries. Flag either one when its named scope is narrower than the body's deliverables or sections; for example, a title naming two workflow threads over a five-thread body flips the finding on, while a title that covers those five threads flips it off. Fix by widening the stale field in place per **Rewrite in place**. Keep this distinct from **Structural check**, which checks presence, and **Contradictions**, which checks consistency rather than under-coverage.
- **Ambiguity / under-specification**: missing requirements, unstated assumptions, vague pointers, or over-compressed prose that lead to divergent implementations; an unresolved either/or is a **Decide or label** finding routed through that rule's reconcile-else-surface procedure: when the evidence base reconciles the decision the finding carries the recommended resolution as its fix, and when no evidence settles it the finding carries the labeled decision with its options and at least one suggested path, while a labeled open decision that omits the why-open clause that rule requires, or whose named default carries an evidence-decisive rationale, is a reconcile finding under it carrying that default as its fix. Over-compression is judged against **Compact only to the implementable floor**, and any reference carrying a position claim (a line-number form such as a `:N` path suffix, a bare `line N`, or an `around lines N–M` range, or an ordinal list-position anchor such as "step 6", "item 3", or "the second bullet") is flagged against the `<markdown_policy>` soft-pointer rule, while a reference to a mutable set carried by a frozen count or by an enumeration snapshot of the set's current members is flagged against that section's count-stable rule, leaving the subject-matter quantities that rule keeps legal unflagged.
- **Over-specification**: constraints that needlessly narrow an implementation choice the task meant to leave open; a choice meant to stay open is labeled per **Decide or label** rather than silently narrowed.
- **Acceptance proof surface**: flag an Acceptance item whose verification depends on the commit message or the pull-request description, citing the `<body>` **Deliverable items flip.** surface rule. Route the disposition through **Decide or label**: move the proof onto a tree artifact, or drop the item when the remaining Acceptance still proves every promise. Judge the proof's availability here; **Implementer-runnable** separately judges whether the verification action is user-gated.
- **Restated standing rules**: body passage instructs the implementer with a copy of a rule that the `<body>` corollary says belongs in a standing project instruction. A copy that already diverges from its source is a contradiction and blocks; a faithful copy is a note under the **Blocking bar**, recorded because copied rules drift from their source. Replace the copy with a standing-rule citation, or drop it when the surrounding text carries nothing else. Keep this distinct from **Over-specification**, which narrows an implementation choice, and apply the **Task-specific gates only** acceptance clause for generic project-gate items: a generic gate is a restatement, while a task-specific executable check remains valid.
- **Rule-waiving exclusions**: an `**Out of scope:**` entry exempts the task's own work from a standing repo rule, a guardrail-doc boundary, or a project gate, which the waiver test in **Declare exclusions as an Out of scope boundary** places outside the block. This is the mirror of **Restated standing rules**: that finding catches a rule copied into a body, this one catches a rule opted out of. Severity follows the waived authority: a waived `CHARTER.md` boundary escalates to the **Charter check** disposition, while any other waived standing rule is an ordinary readiness issue routed through **Decide or label**. An entry that narrows work draws no finding, including one tracking a carve-out its governing rule already provides.
- **Negation-framed behaviour**: behaviour defined as "not X" that an implementer must invert to act on; reframe per the body's positive, action-oriented rule, preserving the technical detail and moving rejected-option rationale to its named home.
- **Sensitive or user-specific detail**: body text embeds identifying or sensitive specifics without an explicit need; point the finding at **Redact by generalizing** rather than restating the rule.
- **Append-framed artifact edits**: a task changing an existing artifact is framed as "add X" while an affected passage exists; flag it per **Rewrite in place, don't append** unless the rule's genuine-addition carve-outs apply.
</readiness_checklist>
<backlog_coherence>
The joint lens set for a *set* of live tasks read together, standing beside `<readiness_checklist>` rather than inside it. The checklist judges one task against the code; these lenses judge the selected tasks against each other and against the code as it stands, which is the defect class every per-task surface structurally misses: two tasks that are each individually ready can still contradict each other, double-own one edit, reintroduce a hazard a sibling fixes, or sit stale against work that shipped after they were written. This block is the family's single source for that lens set: `task_fix` runs it in its assess phase and `auto_shaper_task` resolves what it surfaces, each citing this tag rather than restating the lenses.
Two sets define every lens. **C** is the selected live set: the live eligible tasks in scope for this run, picked by a scope filter, an explicit list, or the whole live tree when the caller names no filter. A named scope or explicit list fixes C by exclusion as much as by inclusion: a live task outside it earns no verdict and no repair, and enters the pass only as context, through T when it edits a shared artifact or through `<dependency_signals>`' inbound direction when its body declares an order over a selected task. **T** is the shared target-artifact set: the union of the directories C's `scope` fields name and the files C's bodies link. Both sets come from the conventions this skill already defines (`scope` frontmatter, body links, `status` values, `<dependency_signals>`), so the lens set carries no assumption about any one project's layout.
Two of the lenses below run off an index rather than off a per-task reading, and each index is **written down before any verdict is judged** rather than held in the reader's head. The first is the shared-surface map: for each artifact in T, the tasks in C claiming an edit to it, and for each task, the artifacts and blocks it claim
[…] pełny plik w paczce .zip
Files in this package (4)
- SKILL.md 98 KB
- scripts/discover_tasks.sh 2 KB
- scripts/init_tasks.sh 1 KB
- scripts/lint.py 75 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · theafh/ai-modules | 96 | MIT |
| SimHacker/moollm | 100 | MIT |
| mdiri-ai/SoduWork | 100 | MIT |
| codeaholicguy/ai-devkit | 100 | Apache-2.0 |
| urikanonov/ai-marketplace | 100 | MIT |
| adivmaimon/Caddis | 100 | MIT |
| gridconsole/grid-plugins | 100 | MIT |
| editorgit/agentic-delivery | 100 | MIT |
| CipherNovaa/agent-skills | 100 | MIT |
Database snapshot: 13.11.2026 · package version 117d286a0446 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90Backlog Management
This skill should be used when the user asks to 'add to backlog', 'update backlog', 'check backlog', 'list backlog items', 'prioritize backlog'. Provides conventions for managing the project backlog in .s2s/BACKLOG.md. - 100todo
Add, complete, view, or link plans to items in the project backlog (GitHub issues or brain/todos.md). Use when the user says "todo", "add a todo", "mark done", "what's on the backlog", "show todos", "list tasks", "check off", or wants to manage their task list. - 84backlog
Manage the structured product backlog — pick what to work on next, add/find/list/update items, and migrate legacy items. Use when the user wants to triage, file, or choose backlog work, or says /prawduct:backlog. - 95backlog
Read, work, and maintain a repo's deferred-work items in docs/backlog/, one file per item. Use when the user says "backlog", "check backlog", "what's on my backlog", "work the backlog", "address the backlog", "add to backlog", "clean up backlog", or when a review or task… - 100backlog
Manage this workspace's Markdown tasks through Backlog.md. Use when creating, splitting, selecting, tracking, or closing tasks, or when the user mentions the backlog, task IDs, acceptance criteria, or a Definition of Done. - 100tasks
Work with markdown-based task lists in .llm/todo.md files. Use when managing tasks, working with todo lists, extracting incomplete tasks, marking tasks complete, or implementing tasks from a task list.