taskflow

Solid

Orchestrate multi-phase subagent workflows with pi-taskflow. Use whenever a request spans a whole project or many items — deeply exploring / 探索 / auditing / 审计 / analyzing a codebase, reviewing or migrating many files or modules in parallel, cross-checked/adversarial review, codebase-wide research, or any repeatable orchestration you want to save and rerun. Prefer this over ad-hoc parallel subagents when the work has multiple phases or dynamic fan-out over a discovered list. Also supports subagent-style shorthand (single / parallel / chain) for simple non-DAG delegations you want tracked, resumable, or saveable.

AI & Automation 43 stars 4 forks Updated today MIT

Install

View on GitHub

Quality Score: 84/100

Stars 20%
55
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

<!-- GENERATED FILE — do not edit. Source: skills-src/taskflow/entry.pi.md + core.md (npm run build:skills) --> # Taskflow **Host binding (pi):** everything below is driven through the `taskflow` tool (`action: "run" | "verify" | …`) and the `/tf` slash commands. Where an example shows a host-neutral invocation like `verify`, use the pi form (`action: "verify"` or `/tf verify`). Build and run **declarative, multi-phase workflows** of subagents. The runtime holds intermediate results and the phase DAG, so your main context only receives the final answer — not every step's transcript. ## Documentation map (progressive loading) This file teaches the core: phase types, control flow, interpolation, and the mistakes that break flows. Load the companion files **only when needed**: | File | Load when you need | |------|--------------------| | `patterns.md` | **Designing a non-trivial flow.** Proven flow archetypes (audit fan-out, self-healing rework, plan→approve→execute, dynamic replanning, tournament synthesis, incremental audit), anti-patterns, and the production-flow quality checklist. | | `advanced.md` | Shared Context Tree (`ctx_*` tools, `ctx_spawn` sub-graphs), workspace isolation (`cwd: temp/dedicated/worktree`), dynamic sub-flow (`flow{def}`) contracts & security caps, and the **incremental recompute suite** (`ir` / `provenance` / `why-stale` / `recompute` / `cache-clear`). | | `configuration.md` | Every knob: per-phase `model`/`thinking`/`tools`/`cwd`, concurrency mo...

Details

Author
heggria
Repository
heggria/taskflow
Created
1 months ago
Last Updated
today
Language
TypeScript
License
MIT

Integrates with

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Listed

task-flow

Use when implementing a feature or multi-step task end-to-end — orchestrates spec intake, adaptive analysis, planning, and a per-task implement/verify/review loop over superpowers, with a single human gate after the plan; includes a human-pulled respec gate to correct the spec mid-build.

0 Updated 1 weeks ago
Endika
Testing & QA Listed

flow

Orchestrates the full supermodo development pipeline end-to-end for one task, running each stage in its own subagent so the main context stays small. Eight stages: librarian task intake (grilled), work implementation, optional hunt bug audit, tdd fixes for any bugs found, a mandatory tests gate (suite green + coverage target), refactor, a mandatory post-refactor verify gate, a final librarian docs pass, and commit. Supports entering at a later stage (--from work|hunt|tests|refactor|librarian|commit) and three job sources: an existing docs/work triad, a backlog entry, or a completely new task — with a context-aware "next job" suggestion when none is named. Use when the user wants to run the whole pipeline, "take this task from spec to commit", orchestrate a feature end-to-end, run the full flow (or the flow from a given stage), or drive a task through the complete dev-to-commit process — anything that means coordinating grill → work → hunt → tdd → tests → refactor → librarian → commit rather than a single stag

1 Updated 3 days ago
supermodo
AI & Automation Solid

workflow

Orchestrate a MULTI-PHASE, dependent, or resumable run over many provider subagents from a JS script, off the main context (`cc-fleet workflow`). Use for fan-out→barrier→synthesis, per-item pipelines, loop-until-dry, or a run that must survive a kill and `--resume` from its journal. NOT a flat fan-out of independent tasks (that is /cc-fleet:subagent — cheaper, no script); NOT interactive collaboration (that is /cc-fleet:team); NOT trivial single-shot work for the main session.

198 Updated 1 weeks ago
ethanhq