project-board
/project-board
Work the shared project task board (kanban + dependency-aware plan + milestones + timeline) that humans edit in the Dev workbench - decompose objectives, claim tasks, track progress, file findings, assign to subagents or humans, and run the board in a loop. Use for /board, task tracking, project planning, or when audits produce actionable findings.
- Author
- Navinspire-ia ↗
- Repository
- navin ↗
- Licence
- AGPL-3.0
- Last repository change
- 26.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.
AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.
What it does and when to use it
Work the shared project task board (kanban + dependency-aware plan + milestones + timeline) that humans edit in the Dev workbench - decompose objectives, claim tasks, track progress, file findings, assign to subagents or humans, and run the board in a loop. Use for /board, task tracking, project planning, or when audits produce actionable findings.
Original author description
Work the shared project task board (kanban + dependency-aware plan + milestones + timeline) that humans edit in the Dev workbench - decompose objectives, claim tasks, track progress, file findings, assign to subagents or humans, and run the board in a loop. Use for /board, task tracking, project planning, or when audits produce actionable findings.
How it works
- Overview
- Discipline
- Planning an objective
- Intelligent assignment
- Board autonomy (per-project consent)
- Loop mode
- Anti-patterns
SKILL.md preview
---
name: project-board
description: Work the shared project task board (kanban + dependency-aware plan + milestones + timeline) that humans edit in the Dev workbench - decompose objectives, claim tasks, track progress, file findings, assign to subagents or humans, and run the board in a loop. Use for /board, task tracking, project planning, or when audits produce actionable findings.
metadata: {"navin":{"emoji":"📋","category":"devops"}}
---
# Project Board
## Overview
The board (`board` tool) is the shared workspace between you and humans: they see it live as a kanban plus an Evolutions timeline in the Dev workbench, and can edit or report issues at any time. Treat it as the single source of truth for what is done, in progress, and missing. Statuses: `backlog → planned → in_progress → review → audit → fix → done`, plus `blocked`.
Tasks form a dependency graph through `depends_on`. The board derives from it the only three facts you need to decide what to do:
- **ready** - every dependency is `done`, so it can start now.
- **blocked** - a dependency is unfinished or missing, or a human parked it in `blocked`.
- **critical path** - the longest chain of open tasks. Shortening it shortens the whole project; a high-priority leaf only helps itself.
## Discipline
1. **Ask the board, don't guess**: `board next` returns the ready queue already sorted (critical path first, then the tasks that unblock the most work, then priority). Pick the top item. Never scan `list` and eyeball a choice - `next` is the deterministic contract, and it explains itself when nothing is ready.
2. **One at a time**: `board claim` sets you as assignee and moves the task to `in_progress`. Keep exactly one task in flight per actor; a subagent may hold its own. `next` tells you what is already in flight.
3. **Record as you go**: `comment` findings, decisions, and file references on the task - humans read these. Move to `review` when a human should check.
4. **Never close what you did not verify**: `done` requires evidence when
`validation` is `test`, `lint`, or `verify` (pass `evidence=` on move/update).
A move to `done` records ledger progress itself; pass `claim_next=true` to
claim the next ready task in the same call. Call `ledger_progress` only to
record a failed attempt (`ok=false`). If you could not verify,
use `review` and say why. A wrong `done` corrupts every downstream `ready`
computation.
5. **One call per board change**: file a whole plan with one `create tasks=[...]` (dependencies may name earlier titles in the list); never one `create` per task. Every board call is a full model round trip.
6. **File what you find**: audits and reviews (/inspect, /fortify, /probe…) must convert each confirmed finding into a task - `create` with `status=fix`, severity mapped to `priority`, and the file path in the description.
7. **Mission ledger**: for multi-step systems use `ledger_init` / `ledger_progress` /
`ledger_replan`. Prefer local replan; pause on budget/human blockers.
A one-shot (deck, memo, one file, typo) is not a mission: do it now.
## Planning an objective
When asked to plan something substantial, decompose before executing:
1. `board plan` first - never plan on top of an unknown board.
2. Create a milestone per outcome (`milestone_create`, with `target_date` when there is a real deadline).
3. Create tasks under it (`milestone_id`), each one a single verifiable deliverable with acceptance criteria in the description.
4. **Wire the order with `depends_on`, not with priorities.** Priority says how much it matters; `depends_on` says what is physically impossible before something else. This is what makes the plan executable: the board then computes the ready queue and the critical path for you, and parallel work falls out for free.
5. Assign each task to whoever should do it (see below), then report the plan in one line (milestones, critical path length) and start the first ready task, unless the user asked only for a plan.
Keep the graph clean: `plan` reports dependency cycles and references to unknown tasks. Both make tasks permanently unready, so fix them on sight rather than working around them.
## Intelligent assignment
- **Subagent**: independent, well-scoped task → `spawn` with a complete brief (subagents cannot see history), assignee `subagent:<label>`. The subagent claims, works, comments, and closes its own task via the `board` tool. Several ready tasks with no dependency between them can run in parallel - that is exactly what the ready queue is for.
- **Human**: decision, approval, credentials, or anything irreversible → set status `blocked`, assignee `human:<name>`, comment what you need, and ask with `ask_user` (or `message` when the turn has it, see `human-approval`).
- **Yourself**: sequential or context-heavy work.
## Board autonomy (per-project consent)
Projects can enable Autonomy in the Tasks panel (consent stored in
`.navin/board/settings.json`). When Runtime Context reports it enabled:
- **Chain ready tasks** inside the run you were invited into (Run agent,
/board task, /forge, /cruise, /mission, or a loop cron) without asking the
user between cards. Stop and notify only on `blocked`.
- **Git isolation only with Auto-branch ON** (Runtime Context says which):
`board claim` then creates and switches to an isolated `navin/task-<id>`
branch and records it on the task; commit your work there, never on the
branch the user was on. With Auto-branch OFF, stay on the user's branch
and follow their commit and push preferences.
- **PR on done only for a task branch**: moving such a task to `done`
pushes its branch and opens the pull request (the PR URL lands on the
task). Without a task branch nothing is pushed for you. Do not merge PRs
yourself; merging stays with the human.
- **GitHub issues**: `board sync_github` imports open GitHub issues as tasks;
`board sync_github task_id=<id>` creates the mirror issue for one task.
Done tasks with a linked issue close it automatically.
- Destructive git operations (force-push, hard reset, deletes) still require
explicit user approval, autonomy or not.
When autonomy is off, work only the task the user named and ask before
claiming more.
## Loop mode
To process the board continuously, create a cron job bound to this session (see `cron` tool) with a message like: "Process the project board: `board next`, claim the top ready task, execute it or spawn a subagent, comment the evidence, move it to done or review, then stop. Report only if a human is blocked." Prefer intervals of 15+ minutes; the run defers automatically while the session is busy.
Each cycle is one task, not a marathon: claim, execute, verify, comment, move, stop. Stop the cycle early when `next` reports nothing ready, and only notify a human when a decision or a blocker actually needs them.
## Anti-patterns
- Picking a task by scanning the list instead of asking `next`
- Encoding execution order as priorities instead of `depends_on`
- Marking `done` without verification evidence, or claiming several tasks at once
- Working on something with no board trace when a board exists
- Duplicating tasks instead of commenting the existing one
- Deleting human-created tasks (comment and let humans delete)
- Notifying humans on every tick of a loop - only signal decisions and blockers
Versions
The database has no other skills named project-board.
Database snapshot: 13.11.2026 · package version 3cd4ff4057cf (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
- 100pm-board
Use when the user asks for the task board, kanban, what is in progress, or asks to move, add, insert, or close a card on the board. Renders the columns from Now to Done and applies the shared roadmap order and edit rules in its edit modes. Read-only in view mode. - 96board
Start the local queue board (kanban, plans, dependencies, statistics, "Waiting on you") for the current project and give the user the link. Use when the user types "/ravenseat:board", "start the board", "open the board", "show me the queue board", or asks how to see the board. - 100cliban
Drive the local cliban kanban board via its CLI. Use when the user mentions cliban, kanban, ticket, issue, project, milestone, or asks you to capture/move work items, or asks what changed/what happened on the board. - 82board-steward
Tracks active work in a project kanban (board.json + live HTML board served on 127.0.0.1:7891). MUST USE when user says — shipped, deployed, merged, fixed, completed, finished, verified, done, deferred, blocked, paused, moved, add card, log this, track it, what shipped, what's… - 100plan
Decompose a spec into milestones and atomic tasks with dependency ordering, risk register, and complexity sizing. Use when you say `plan how to build this`, `break this into milestones`, or `decompose this spec`, and run it after spec. Do NOT use to decide what to build (use… - 88create-session-board-canvas
Open and maintain a live canvas for the current session's plan, kanban tasks, primary/subagent team, progress, blockers, owned PRs/issues, head-pinned CI, and delivery status, with opt-in cross-session project rollups and an operator attention inbox. USE FOR: create a canvas…