Long Task Coordinator
Run migrations, research, and multi-session agent work with a durable state file, honest awaiting-result status, and acceptance checks before claiming done.
Overview
Long Task Coordinator is a journey-wide agent skill that coordinates long-running work with explicit state, recovery, and honest status transitions—usable whenever a solo builder must not rely on chat memory alone.
Install
npx skills add https://github.com/charon-fan/agent-playbook --skill long-task-coordinatorWhat is this skill?
- Resumes interrupted work from persisted state instead of chat memory alone
- Supports delegate-and-wait flows with explicit ownership and awaiting-result as a valid state
- Requires proof on close: saved state must match reality before marking complete
- Smoke-test eval prompts cover resume, delegation, and acceptance-criteria closure
- Enforces recovery rules and honest status transitions for long-running tasks
- 3 eval smoke-test prompts with explicit expected behaviors
Adoption & trust: 530 installs on skills.sh; 58 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Multi-step agent work stalls or restarts mid-flight because nothing durable records status, owners, or what “done” actually means.
Who is it for?
Sessions that span migrations, chunked research, or parallel worker tasks where you need resume, await, and verify-before-done discipline.
Skip if: Quick one-off answers, tasks with no need for persistence, or work where a simple todo list in the repo already suffices.
When should I use this skill?
Work should not depend on chat memory alone; resuming interrupted multi-step work; delegating chunks with honest waiting states; or closing long tasks only after acceptance criteria are met.
What do I get? / Deliverables
You get recovered next steps from saved state, tracked delegation with valid waiting states, and a justified completion claim backed by acceptance criteria.
- Persisted task state with status and next action
- Ownership or worker tracking
- Completion note justified against acceptance criteria
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Half-finished schema migration: reload state, report the true next step, then propose only incremental work.
Chunk a long third-party integration into owned subtasks while recording who waits on external API results.
Coordinate a multi-day release checklist without claiming success until persisted status matches completed steps.
Resume an extended incident remediation thread with blockers and return conditions written to disk.
Track prototype milestones across sessions so validation demos do not repeat already-finished steps.
How it compares
Use instead of free-form “continue where we left off” prompts that skip state files and acceptance checks.
Common Questions / FAQ
Who is long-task-coordinator for?
Solo builders and small teams running Claude Code, Cursor, or similar agents on work that crosses multiple sessions and needs accountable progress tracking.
When should I use long-task-coordinator?
In Build during multi-step implementation, in Ship during long migrations or launch prep, in Operate when iterating on lengthy fixes, and in Validate when scoped prototypes need phased checkpoints—not for trivial single-reply tasks.
Is long-task-coordinator safe to install?
Review the Security Audits panel on this Prism page and the skill source; persistence may imply filesystem writes—confirm paths and secrets handling in your environment.
SKILL.md
READMESKILL.md - Long Task Coordinator
# Long Task Coordinator Eval Prompts Use these prompts to smoke-test whether the skill routes to the right behavior and enforces its acceptance criteria. ## Prompt 1: Resume interrupted work ```text We were halfway through a multi-step migration last session. Please resume it safely, and do not rely on chat memory alone. ``` Expected behavior: - Recommends or uses `long-task-coordinator` - Looks for or creates a durable state file - Recovers status before proposing new work - Reports the next step from persisted state ## Prompt 2: Delegate and wait honestly ```text Split this long research task into worker-sized chunks, track who owns what, and tell me if we are waiting rather than pretending it failed. ``` Expected behavior: - Introduces explicit ownership or worker tracking - Uses `awaiting-result` as a valid state when appropriate - Records checkpoint and return condition ## Prompt 3: Close with acceptance criteria ```text Before you call this long-running task done, prove that the state is saved and the completion claim is justified. ``` Expected behavior: - Checks acceptance criteria explicitly - Verifies the saved status matches reality - Confirms completed work, blockers, and next action or completion note are recorded # Long Task Coordinator Coordinate long-running work with explicit state, recovery rules, and honest status transitions. ## What this skill is for `long-task-coordinator` is for work that should not depend on chat memory alone. It is useful when: - A task spans multiple turns or sessions - Work is delegated to subagents, background jobs, or automation - The task needs checkpoints, retries, or waiting states - A user may return later and ask to resume from the last known state This skill is intentionally abstract and portable. It does not assume any specific business domain, toolchain, or runtime. ## Installation ```bash ln -s /path/to/agent-playbook/skills/long-task-coordinator ~/.claude/skills/long-task-coordinator ln -s /path/to/agent-playbook/skills/long-task-coordinator ~/.codex/skills/long-task-coordinator ln -s /path/to/agent-playbook/skills/long-task-coordinator ~/.gemini/skills/long-task-coordinator ``` ## Core loop Every coordination round follows the same sequence: ```text READ -> RECOVER -> DECIDE -> PERSIST -> REPORT -> END ``` The ordering matters. If you report before you persist, the next round cannot recover reliably. ## What gets persisted At minimum, the state file should record: - Goal - Success criteria - Current status - Current step - Completed work - Next action - Next checkpoint - Blockers - Owners or delegated workers ## Valid states Use explicit status values instead of vague progress messages: - `running` - `awaiting-result` - `paused` - `blocked` - `complete` `awaiting-result` is important. If a worker was dispatched successfully, the task is waiting, not failing. ## Acceptance criteria The skill has done its job when: - A durable state file was created or updated - The task status is explicit and truthful - The next checkpoint is recorded - Delegated work is tracked with clear ownership - The progress report matches the persisted state ## Good use cases ### Example 1: Resumable research An agent performs research across multiple turns, saving findings and next checkpoints in a shared state file so the work can resume later without reconstructing the thread. ### Example 2: Multi-agent delivery One agent coordinates work, delegates bounded tasks to workers, records owner assignments and return conditions, then resumes when results arrive. ### Example 3: Scheduled follow-up A long-running operational task checks a queue periodically, persists each checkpoint, and reports only from the saved state. ## Not the same as other skills - Use `planning-with-files` for general file-based planning. - Use `workflow-orchestrator` for hook-based skill chaining. - Use `long-task-coordinator` when recovery and state transitions are the hard part. ## Re