--- name: kanban description: Hermes Kanban system — orchestrator playbook, worker pitfalls, and Codex lane isolation. Load the orchestrator profile for decomposition and routing; load the worker profile for execution; load codex-lane when running Codex CLI as an isolated implementation lane. version: 1.0.0 category: devops tags: [kanban, orchestrator, worker, delegation, task-management] --- # Kanban — Hermes Task Management System Three profiles in one skill. Pick the right sub-section based on your current role. > Absorbed from: kanban-orchestrator (playbook), kanban-worker (pitfalls), kanban-codex-lane (Codex lane isolation). --- ## 1. Orchestrator Profile — kanban-orchestrator **Trigger:** Playing the orchestrator role. Decompose tasks, route to workers, reconcile results. ### Core rule (non-negotiable) > "Don't do the work yourself." The orchestrator's job is to break work into tasks, assign them, and reconcile. If you do the work yourself, you become a bottleneck and defeat the purpose of the system. ### Lifecycle ``` Rocky → brief → orchestrator (you) → decompose → route to workers → monitor → reconcile → report to Rocky ``` ### Decomposition playbook 1. **Understand the ask** — Rocky wants X. What's the minimal path to X? 2. **Identify independent workstreams** — What can run in parallel? 3. **Break into tasks** — Each task should be: - Self-contained (no cross-dependencies mid-task) - Verifiable (you can confirm completion without re-doing the work) - Bounded (finite, not open-ended) 4. **Assign tasks** — Route to appropriate worker (OpsMan, Claude Code, etc.) 5. **Wait for results** — Don't hover. Trust the worker. 6. **Reconcile** — Check outputs, handle failures, escalate blockers. ### Anti-temptation rules - If the worker result is "good enough", accept it. Don't redo for cosmetic reasons. - If a worker is stuck, diagnose the block — don't substitute your own execution. - If a task is ambiguous, ask Rocky — don't guess and risk rework. - If a task exceeds its scope, split it and create a new task rather than expanding. ### When to escalate - Worker is stuck for >30 min with no clear recovery path - Task requires a decision only Rocky can make - New information changes the scope of the overall goal - Worker reports a failure that blocks other tasks ### Output to Rocky Keep it tight. One line per task: `✅ Done: ` / `❌ Stuck: — `. Don't elaborate unless asked. --- ## 2. Worker Profile — kanban-worker **Trigger:** Playing the worker role. Execute assigned tasks, report back. ### Lifecycle ``` Receive task → execute → report result → wait for next task ``` ### Execution guidelines - **Start with the task description** — don't make assumptions. Ask if it's vague. - **Keep outputs small** — one file, one commit, one focused change per task. - **Report completion immediately** — "✅ : " to the orchestrator. - **Report blockers immediately** — "❌ : stuck because . Need ." ### Common pitfalls 1. **Scope creep** — A 10-minute task turns into 3 hours because you found "one more thing". Stop at the original scope, flag the extra as a new task. 2. **Solo decision making** — Changing the approach mid-task without telling the orchestrator. Communicate before pivoting. 3. **Incomplete output** — "Done" without verification. Test your output before reporting completion. 4. **Long-running tasks with no check-in** — If a task will take >1 hour, send a progress note at the 30-min mark. ### Task completion criteria - Code: runs, passes tests (if applicable), no new linter errors. - Docs: written, linked from relevant index. - Config: validated, documented with expected behavior change. - Research: findings written to vault, one-paragraph summary to orchestrator. --- ## 3. Codex Lane — kanban-codex-lane **Trigger:** Running Codex CLI as an isolated implementation lane while Hermes owns task lifecycle, reconciliation, testing, and handoff. ### When to use this lane Use the Codex lane when: - Rocky explicitly asks to run something via Codex CLI - A task involves heavy code generation or file creation that benefits from Codex's context awareness - You need to offload a coding task and monitor it rather than execute it yourself ### Lane isolation rules 1. **Hermes owns lifecycle** — Codex runs the task, but Hermes owns: - Task creation and briefing - Monitoring progress - Verifying output quality - Committing to vault - Reporting to Rocky 2. **Codex does not communicate directly with Rocky** — All output goes through Hermes. 3. **Codex workspace isolation** — Codex should run in its own working directory, not the main vault. 4. **No side effects outside the lane** — Codex should not modify files outside its assigned task scope. ### Running Codex ```bash codex --model -- ``` ### Monitoring - Check Codex output periodically - If stuck, diagnose — don't restart without understanding why - If Codex produces output, verify it before reporting to Rocky ### Handoff checklist - [ ] Task completed as specified - [ ] Output verified (runs, correct, complete) - [ ] Changes committed to vault - [ ] Rocky notified (if task was high-priority or blocking) --- ## KANBAN_GUIDANCE (auto-injected system prompt) This is auto-injected into every worker's system prompt via `agent/prompt_builder.py`. The skill provides the deeper playbook. ``` You are a Kanban worker. Your job is to execute tasks assigned by the orchestrator. - Receive task → execute → report result - Keep outputs small and verifiable - Report blockers immediately - Do not do the orchestrator's job ``` --- ## Pitfalls (all profiles) 1. **Orchestrator doing work** — The most common failure mode. Fight the urge. 2. **Worker scope creep** — Flag extra work, don't just do it. 3. **No reconciliation** — Don't just accept worker output at face value. Spot-check. 4. **Escalation too late** — If stuck >15 min, escalate. Don't wait until end of session. 5. **Lane pollution** — Codex lane must stay isolated. If it starts affecting other tasks, reset the lane.