---
type: template
system: atlas-kanban
status: active
owner: Will / Atlas
created: 2026-05-14
related:
  - "[[Atlas Kanban Durable Project Workflow]]"
  - "[[Atlas Capability Upgrade Program]]"
---

# Kanban Task Graph Templates

Copy these patterns when turning durable work into Hermes Kanban tasks. Replace placeholders in angle brackets. Always verify available profiles first:

```bash
hermes profile list
hermes kanban --board <board> stats --json
```

Default profile routing:

- Spec/discovery: `ops`, `researcher`, or `writer`
- Task graph creation/status synthesis: `orchestrator`
- Code implementation: `engineer`
- Hermes/config/host/runbook operations: `ops`
- Review gate: `reviewer`
- Durable prose/status: `writer` or `atlas`
- Keep `default` reserved for stable production gateway unless Will explicitly asks otherwise.

Common metadata shape for handoffs:

```json
{
  "changed_files": [],
  "artifact_paths": [],
  "verification": [],
  "decisions": [],
  "residual_risk": [],
  "retry_notes": ""
}
```

For code/config/ops changes, the implementer should leave a `review-required handoff` comment with metadata and then block instead of completing. Docs/research/spec-only tasks may complete directly when the artifact is the deliverable.

## Template A: spec -> implementation -> reviewer -> synthesis

Use for a durable code/config/runbook feature with one clear implementation path.

Graph:

```text
spec:<feature> -> implement:<feature> -> review:<feature> -> synthesize:<feature> status
```

Assignees and workspaces:

| Stage | Assignee | Workspace | Max runtime | Skills | Completion policy |
|---|---|---|---|---|---|
| Spec | `ops` or `researcher` | `scratch` | `45m` | optional domain skill | Complete with artifact/spec metadata. |
| Implementation | `engineer` for code, `ops` for Hermes/config/runbook | `worktree` for code, `dir:<abs-path>` for durable notes/config, `scratch` for generated artifacts | `2h` | `test-driven-development` for code, `hermes-agent` for Hermes work, `obsidian` for vault notes | Comment review-required metadata, then block. |
| Review | `reviewer` | same repo/worktree or `scratch` if artifact-only | `1h` | `github-code-review` for code, relevant domain skill | Complete if approved; block with exact changes if not. |
| Synthesis | `writer` or `atlas` | `scratch` | `30m` | optional `obsidian` | Complete with final status/report artifact. |

CLI skeleton:

```bash
BOARD=<board>
SPEC=$(hermes kanban --board "$BOARD" create "spec: <feature>" \
  --assignee ops \
  --workspace scratch \
  --priority 10 \
  --max-runtime 45m \
  --body "Write implementation-ready spec: goal, files/tools to touch, verification, risks, recommended owner, reviewer-gate requirement." \
  --json | jq -r .task_id)

IMPL=$(hermes kanban --board "$BOARD" create "implement: <feature>" \
  --assignee engineer \
  --parent "$SPEC" \
  --workspace worktree \
  --skill test-driven-development \
  --priority 8 \
  --max-runtime 2h \
  --body "Implement exactly the parent spec. Inspect status first. Keep changes narrow. If code/config/ops changed, add review-required metadata comment and block instead of completing." \
  --json | jq -r .task_id)

REVIEW=$(hermes kanban --board "$BOARD" create "review: <feature>" \
  --assignee reviewer \
  --parent "$IMPL" \
  --workspace worktree \
  --skill github-code-review \
  --priority 7 \
  --max-runtime 1h \
  --body "Review implementation against parent spec, tests, safety, secrets, and unintended diffs. Complete if approved; block with exact required changes if not." \
  --json | jq -r .task_id)

hermes kanban --board "$BOARD" create "synthesize: <feature> status" \
  --assignee writer \
  --parent "$REVIEW" \
  --workspace scratch \
  --priority 5 \
  --max-runtime 30m \
  --body "Read parent handoffs and produce final status: artifacts, verification, decisions, residual risks, next actions."
```

Implementation review-required metadata:

```json
{
  "changed_files": ["..."],
  "tests_run": ["..."],
  "verification": ["..."],
  "diff_path": "<repo-or-worktree-path>",
  "decisions": ["..."],
  "residual_risk": []
}
```

## Template B: parallel discovery lanes -> synthesis -> implementation -> reviewer

Use when the approach is not yet known and multiple discovery lanes can run in parallel.

Graph:

```text
discovery:<lane A> ┐
discovery:<lane B> ├-> synthesize:<decision> -> implement:<chosen path> -> review:<chosen path>
discovery:<lane C> ┘
```

Assignees and workspaces:

| Stage | Assignee | Workspace | Max runtime | Skills | Completion policy |
|---|---|---|---|---|---|
| Discovery lanes | `researcher`, `ops`, or `engineer` depending on source | `scratch`, or `dir:<abs-path>` for repo/vault inspection | `45m` each | domain-specific | Complete with sources/artifacts/risks. |
| Synthesis | `writer`, `ops`, or `atlas` | `scratch` | `45m` | optional `obsidian` | Complete with recommendation and implementation spec. |
| Implementation | `engineer` or `ops` | `worktree` or `dir:<abs-path>` | `2h` | implementation skill(s) | Comment review-required metadata, then block. |
| Review | `reviewer` | matching repo/workspace | `1h` | review skill(s) | Complete or block with exact changes. |

CLI skeleton:

```bash
BOARD=<board>
A=$(hermes kanban --board "$BOARD" create "discovery: <lane A>" \
  --assignee researcher --workspace scratch --priority 10 --max-runtime 45m \
  --body "Investigate <lane A>. Return sources, options, recommendation, verification, risks." --json | jq -r .task_id)
B=$(hermes kanban --board "$BOARD" create "discovery: <lane B>" \
  --assignee researcher --workspace scratch --priority 10 --max-runtime 45m \
  --body "Investigate <lane B>. Return sources, options, recommendation, verification, risks." --json | jq -r .task_id)
C=$(hermes kanban --board "$BOARD" create "discovery: <lane C>" \
  --assignee ops --workspace scratch --priority 10 --max-runtime 45m \
  --body "Investigate <lane C>. Return current-state evidence, options, verification, risks." --json | jq -r .task_id)

SYNTH=$(hermes kanban --board "$BOARD" create "synthesize: <decision>" \
  --assignee writer \
  --parent "$A" --parent "$B" --parent "$C" \
  --workspace scratch --priority 8 --max-runtime 45m \
  --body "Read all discovery parent handoffs. Produce chosen approach, tradeoffs, implementation spec, verification plan, and reviewer-gate requirement." --json | jq -r .task_id)

IMPL=$(hermes kanban --board "$BOARD" create "implement: <chosen path>" \
  --assignee engineer --parent "$SYNTH" --workspace worktree \
  --priority 7 --max-runtime 2h --skill test-driven-development \
  --body "Implement the synthesis recommendation. Keep diff narrow. Add review-required handoff and block if code/config changed." --json | jq -r .task_id)

hermes kanban --board "$BOARD" create "review: <chosen path>" \
  --assignee reviewer --parent "$IMPL" --workspace worktree \
  --priority 6 --max-runtime 1h --skill github-code-review \
  --body "Review implementation against synthesis recommendation and tests. Complete if approved; block with exact findings if not."
```

Discovery handoff metadata:

```json
{
  "sources_read": ["..."],
  "artifact_paths": ["..."],
  "recommendation": "...",
  "verification": ["..."],
  "risks": ["..."],
  "open_questions": []
}
```

## Template C: ops incident: triage -> mitigation -> verification -> postmortem

Use for incidents, broken gateway/profile/tooling, failed dispatchers, or service degradation.

Graph:

```text
triage:<incident> -> mitigate:<incident> -> verify:<incident> -> postmortem:<incident>
```

Assignees and workspaces:

| Stage | Assignee | Workspace | Max runtime | Skills | Completion policy |
|---|---|---|---|---|---|
| Triage | `ops` | `scratch` | `30m` | `systematic-debugging`, `sysadmin-health` if relevant | Complete with symptoms, scope, likely cause, safe mitigation plan; block if credentials/policy needed. |
| Mitigation | `ops` | `dir:<config/repo>` or `scratch` | `1h` | `systematic-debugging`, `hermes-agent` for Hermes | For config/ops changes, comment review-required metadata and block unless the task explicitly authorizes safe immediate completion. |
| Verification | `reviewer` or `ops` | `scratch` | `30m` | relevant ops skill | Complete with health checks and residual risks. |
| Postmortem | `writer` | `scratch` or `dir:<vault>` | `45m` | `obsidian` | Complete with durable postmortem path. |

CLI skeleton:

```bash
BOARD=<board>
TRIAGE=$(hermes kanban --board "$BOARD" create "triage: <incident>" \
  --assignee ops --workspace scratch --priority 10 --max-runtime 30m \
  --skill systematic-debugging \
  --body "Identify symptoms, affected services, current status, likely root cause, non-secret log pointers, risk level, and safe mitigation plan. Block on destructive/policy decisions." --json | jq -r .task_id)

MITIGATE=$(hermes kanban --board "$BOARD" create "mitigate: <incident>" \
  --assignee ops --parent "$TRIAGE" --workspace scratch --priority 9 --max-runtime 1h \
  --skill systematic-debugging --skill hermes-agent \
  --body "Apply the narrow approved mitigation from triage. Back up config before editing. Do not print secrets. Verify status after any restart. For config/ops changes, leave review-required metadata and block unless explicitly safe to complete." --json | jq -r .task_id)

VERIFY=$(hermes kanban --board "$BOARD" create "verify: <incident>" \
  --assignee reviewer --parent "$MITIGATE" --workspace scratch --priority 8 --max-runtime 30m \
  --body "Verify service health, logs, config parse, dispatcher/gateway status, and that no unrelated changes occurred. Complete if healthy; block with exact findings if not." --json | jq -r .task_id)

hermes kanban --board "$BOARD" create "postmortem: <incident>" \
  --assignee writer --parent "$VERIFY" --workspace scratch --priority 5 --max-runtime 45m \
  --skill obsidian \
  --body "Write durable postmortem: timeline, impact, root cause, resolution, prevention, follow-up tasks, artifact paths."
```

Triage metadata:

```json
{
  "symptoms": ["..."],
  "affected_services": ["..."],
  "log_pointers": ["path plus line/range, no raw secrets"],
  "risk_level": "low|medium|high",
  "likely_cause": "...",
  "mitigation_plan": ["..."]
}
```

## Template D: artifact pipeline: research -> draft -> review -> publish

Use for durable notes, reports, runbooks, decision memos, diagrams, or public/internal docs.

Graph:

```text
research:<artifact> -> draft:<artifact> -> review:<artifact> -> publish:<artifact>
```

Assignees and workspaces:

| Stage | Assignee | Workspace | Max runtime | Skills | Completion policy |
|---|---|---|---|---|---|
| Research | `researcher` or `ops` | `scratch` | `45m` | source/domain skill | Complete with sources, outline, risks, and recommended destination. |
| Draft | `writer` | `scratch` or `dir:<vault>` | `1h` | `obsidian` for vault notes | Complete directly if artifact-only and no risk-bearing change; otherwise request review. |
| Review | `reviewer` | `scratch` or `dir:<vault>` | `45m` | artifact/domain skill | Complete if approved; block with exact changes if not. |
| Publish | `writer` or `atlas` | `dir:<vault>` or destination workspace | `30m` | `obsidian` | Complete with final artifact path and verification. |

CLI skeleton:

```bash
BOARD=<board>
RESEARCH=$(hermes kanban --board "$BOARD" create "research: <artifact>" \
  --assignee researcher --workspace scratch --priority 9 --max-runtime 45m \
  --body "Gather sources and requirements for <artifact>. Return outline, source list, audience, risks, and recommended destination path." --json | jq -r .task_id)

DRAFT=$(hermes kanban --board "$BOARD" create "draft: <artifact>" \
  --assignee writer --parent "$RESEARCH" --workspace scratch --priority 8 --max-runtime 1h \
  --skill obsidian \
  --body "Draft the artifact from parent research. Include wikilinks, frontmatter when appropriate, artifact path, and verification. Complete directly if artifact-only." --json | jq -r .task_id)

REVIEW=$(hermes kanban --board "$BOARD" create "review: <artifact>" \
  --assignee reviewer --parent "$DRAFT" --workspace scratch --priority 7 --max-runtime 45m \
  --body "Review for correctness, completeness, audience fit, links, secrets, and actionability. Complete if approved; block with exact edits if not." --json | jq -r .task_id)

hermes kanban --board "$BOARD" create "publish: <artifact>" \
  --assignee writer --parent "$REVIEW" --workspace dir:/home/will/lab/swarm/swarm-common/obsidian-vault/will/will-shared-zap \
  --priority 6 --max-runtime 30m --skill obsidian \
  --body "Publish final artifact to the durable destination. Verify file exists, links render, and final status names the artifact path."
```

Artifact metadata:

```json
{
  "artifact_paths": ["/absolute/path/to/artifact.md"],
  "sources_read": ["..."],
  "review_findings": [],
  "verification": ["read_file confirmed file exists", "links/frontmatter checked"],
  "publish_destination": "...",
  "residual_risk": []
}
```

## Recovery and status snippets

Inspect a task before acting:

```bash
hermes kanban --board <board> show <task_id>
hermes kanban --board <board> runs <task_id>
hermes kanban --board <board> log <task_id>
```

Recover a stale or failed task:

```bash
hermes kanban --board <board> reclaim <task_id> --reason "stale claim: <evidence>"
hermes kanban --board <board> reassign <task_id> <profile> --reclaim --reason "profile recovery: <reason>"
hermes kanban --board <board> unblock <task_id>
```

Status report skeleton:

```markdown
# <Board/project> status - <date>

## Completed since last report
- <task_id/title>: artifact, verification, downstream effect.

## Running/ready by profile
- <profile>: <task ids/titles>

## Blocked/gave_up items
- <task_id/title>: owner/profile, exact blocker, next action.

## Risks / decisions needed
- ...

## Next planned graph expansion
- ...
```