swarm-master/swarm-common/obsidian-vault/will/will-shared-zap/Templates/Kanban Task Graph Templates.md

type, system, status, owner, created, related

type	system	status	owner	created	related
template	atlas-kanban	active	Will / Atlas	2026-05-14	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:

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:

{
  "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:

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:

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:

{
  "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:

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:

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:

{
  "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:

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:

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:

{
  "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:

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:

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:

{
  "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:

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:

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:

# <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
- ...