rse/ase / plugin/skills/ase-task-dissect
ase-task-dissect
VerifiedDissect the current or given task plan, treated as an epic, domain-wise and logically into cohesive parts and materialize each part as its own separate task plan. Use when the user calls to "dissect", "split", "break up", or "decompose" a large "task" or "plan".
SKILL.md
View on GitHub---
name: ase-task-dissect
argument-hint: "[--help|-h] [--max-parts|-m <count>] [--dry|-d] [--force|-f] [<task-id>[:]] [<dissect-hint>]"
description: >
Dissect the current or given task plan, treated as an epic,
domain-wise and logically into cohesive parts and materialize each
part as its own separate task plan. Use when the user calls to
"dissect", "split", "break up", or "decompose" a large "task" or
"plan".
user-invocable: true
disable-model-invocation: false
effort: high
---
@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
<purpose name="ase-task-dissect">
Dissect a Task Plan
</purpose>
<expand name="getopt"
arg1="ase-task-dissect"
arg2="--max-parts|-m=8 --dry|-d --force|-f --int-reuse-task"
arg3="colon-or-bare">
$ARGUMENTS
</expand>
<objective>
*Dissect* a task plan, treated as an *epic*, domain-wise and logically
into *cohesive parts*, and materialize every part as its own separate
*task plan*.
</objective>
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-dissect.md
Procedure
---------
1. **Determine Task and Hint:**
1. Set <instruction><getopt-arguments/></instruction> initially,
with any leading and trailing whitespace stripped. Inherit the
always existing <ase-task-id/> from the current context. Inherit
the always existing <ase-session-id/> from the current context.
Do not output anything.
2. React on the task id:
<if condition="<getopt-task/> is not empty">
The option parser has already split off the task id prefix
`<id>:` resp. the sole task id `<id>` (never a hint) from
<instruction/>. Set <ase-task-id><getopt-task/></ase-task-id>,
call the `ase_task_id(id: "<ase-task-id/>", session:
"<ase-session-id/>")` tool from the `ase` MCP server to switch
the task, and then only output the following <template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
</template>
</if>
3. React on the dissection hint:
Set <dissect-hint><instruction/></dissect-hint> (set the
dissection hint to the *remaining* instruction), with any
leading and trailing whitespace stripped.
<if condition="<dissect-hint/> is not empty">
Only output the following <template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ hint: **<dissect-hint/>**
</template>
</if>
<else>
No dissection hint was given, so the parts are derived from the
plan alone. Do not output anything.
</else>
2. **Determine Operation:**
1. Determine the current task plan content:
<expand name="task-load-content"></expand>
2. If the <task-content/> is still empty, complain and tell
the user to use the `ase-task-edit` skill first to create a
task plan. Then immediately stop processing this skill.
3. Determine the *placement* of the parts from the frontmatter of
<task-content/>: set <task-group/> to the value of its `Group:`
key and <task-after/> to the list of task ids of its `After:`
key (each empty if the key is absent).
<if condition="<task-group/> is not empty AND <task-group/> is not equal <ase-task-id/>">
The task already is a *member* of the epic <task-group/>, so its
parts *replace* it within this very epic. Set
<part-group><task-group/></part-group> and
<dissect-mode>member</dissect-mode> and only output the following
<template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⊂ epic: **<task-group/>**, ▶ mode: **parts replace task in epic**
</template>
</if>
<else>
The task belongs to *no* epic (or already is an explicit epic
itself), so it *becomes* the epic of its parts. Set
<part-group><ase-task-id/></part-group> and
<dissect-mode>epic</dissect-mode> and only output the following
<template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⊂ epic: **<ase-task-id/>**, ▶ mode: **task becomes epic of parts**
</template>
</else>
3. **Dissect Task Plan:**
1. *Derive the parts* of the epic:
<expand
name="dissect-derive"
arg1="ase-task-dissect"
arg2="<dissect-hint/>"
arg3="<ase-task-id/>"
>
the individual bullet points of the `## SPECIFICATION (WHAT)`,
`## DESIGN (HOW)`, and `## VERIFICATION (WHEN)` sections of the
loaded plan <task-content/>
</expand>
Each `## DESIGN (HOW)` bullet point *MUST* land in the very part
which carries the `## SPECIFICATION (WHAT)` bullet points it
realizes, and each `## VERIFICATION (WHEN)` bullet point *MUST*
land in the very part which carries the `## SPECIFICATION (WHAT)`
and `## DESIGN (HOW)` bullet points it verifies.
A *single* bullet point is *not* the smallest unit here: a bullet
point which itself covers *multiple* domains or concerns *MAY* be
*split* per rule 3 into two or more *bullet point fragments*,
each of which is a complete bullet point of its own, is formed
*exclusively* from the wording of the original bullet point, and
is then assigned to a part like an ordinary bullet point. A split
`## DESIGN (HOW)` or `## VERIFICATION (WHEN)` bullet point
follows the bullet points its fragments realize or verify, so its
fragments *MAY* land in *different* parts.
2. *Identify the parts* according to the task id scheme of the
project: for *every* part in <parts/>, in their derived order,
derive its <part-title/> from its <scope/> according to the
<task-title/> rules of the plan <format/>,
remember its <part-id/> as its <part-proposal/> and call the
`ase_task_newid(title: "<part-title/>", proposal:
"<part-id/>", taken: [ <previous/> ])` tool of the `ase` MCP
server, where <previous/> lists the already re-identified
<part-id/> of all preceding parts (as the tool reserves ids for
scheme `seq` only), and replace the <part-id/> of the part with the `id` field
of its response -- you *MUST* *NEVER* assemble such an id
yourself. Set <id-scheme/> to the `scheme` field of the responses.
Do not output anything related to these MCP tool calls.
<if condition="<getopt-option-dry/> is equal `true`">
Skip these `ase_task_newid` tool calls and keep every <part-id/>
as derived (the report then shows the proposed ids), as the
scheme `seq` permanently reserves every handed-out id, which a
report-only run must not consume.
</if>
Then *derive the dependencies* of the parts: for *every* part,
set <part-after/> to the <part-id/> of exactly those *earlier*
parts it *directly* depends on (a part never depends on a later
one, see the derived order). A part with an empty <part-after/>
is a *root* part: set its <part-after/> to <task-after/>, so it
inherits the predecessors of the dissected task. Finally, set
<terminal-parts/> to the <part-id/> of all parts which *no* other
part lists in its <part-after/>.
3. *Report the parts*:
<expand name="dissect-report" arg1="<ase-task-id/>"></expand>
4. **Materialize Sub-Task Plans:**
The *body* of the dissected plan <task-content/> of <ase-task-id/>
*MUST* stay *untouched*: it is either only re-grouped (frontmatter
only, sub-step 4.4) or, as a whole, replaced by its parts and
deleted (sub-step 4.5) -- *NEVER* edit any of its sections.
1. <if condition="<getopt-option-dry/> is equal `true`">
The dissection is *reported only*, so no artifacts are created at
all. Only output the following <template/> and then *SKIP* the
remaining sub-steps 4.2 to 4.6 and continue with step 5:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ dissection: **<n/>** parts, ▶ status: **dry-run -- no sub-task plans created**
</template>
</if>
2. *Detect target collisions*, strictly *before* writing anything:
Call the `ase_task_list(verbose: false)` tool of the `ase` MCP
server and set <existing/> to the returned `tasks` array. A part
*collides* with an existing task -- like a sub-task plan of a
previous dissection -- if its <part-proposal/> is the `id` of a
task in <existing/> and <id-scheme/> is `any` (as only this
scheme takes over the proposal as the id), or else if its
<part-title/> is the `title` of a task in <existing/> other than
<ase-task-id/> whose `Group:` frontmatter key is <part-group/>
(checked via the `ase_task_load(id: "<id/>")` tool of the `ase`
MCP server for these title matches only, as the ids of the other
schemes derive from the title or a counter). Set the
<part-collision/> of every colliding part to the `id` of this
task, and set <collisions/> to all <part-collision/> (as each
<part-id/> itself was re-identified to a free id in step 3.2).
Do not output anything related to these MCP tool calls.
<if condition="<collisions/> is not empty AND <getopt-option-force/> is not equal `true`">
Only output the following <template/> -- with <collisions/>
rendered as a comma-separated list of code spans -- and then
immediately *STOP* processing the entire current skill, leaving
*all* existing task plans untouched:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⊘ collisions: <collisions/>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ dissection: **<n/>** parts, ▶ status: **targets exist**
</template>
Directly *after* this <template/>, and *before* stopping, give
the corrective hint by expanding the following (which, depending
on the configured <ase-guidance-level/>, may expand into nothing
and hence emit no output at all):
<ase-tpl-hint level="minimal">
Re-run `/ase-task-dissect --force` to overwrite the colliding sub-task plans.
</ase-tpl-hint>
</if>
<if condition="<collisions/> is not empty AND <getopt-option-force/> is equal `true`">
Set the <part-id/> of every colliding part to its
<part-collision/>, so the colliding sub-task plans are
*overwritten* in sub-step 4.3 below, and replace its previous
<part-id/> by it in the <part-after/> of all parts and in
<terminal-parts/>. Do not output anything.
</if>
3. *Compose and persist one sub-task plan per part*:
Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
`ase` MCP server *once* and use the `text` field of its response
for both the <timestamp-created/> and <timestamp-modified/>
information of *all* parts.
Then, for *every* part in <parts/>, in their derived order:
1. Compose a *complete* task plan <part-content/> by closely
following the plan <format/>, where:
- the <task-id/> is <part-id/>,
- the <task-status/> is the *default* state of the task
lifecycle model <ase-project-task-lifecycle/>, as every
part is a *newly created* plan,
- the `Group:` key carries <part-group/>, so all parts are
grouped under the same epic,
- the `After:` key carries <part-after/>, formatted as a
comma-and-space-separated list, and is omitted if
<part-after/> is empty,
- the `Kind:`, `Phase:`, `Tags:`, `Source:`, `Changeset:`,
and `Target:` keys are taken over from the dissected task
*verbatim* (the kind being
inferred from the part content if the task carries no
`Kind:` key),
- the <task-title/> is the <part-title/> of the part,
- the `## SPECIFICATION (WHAT)` section carries *exactly*
the `DOM` and `IFC` bullet points assigned to this part,
- the `## DESIGN (HOW)` section carries *exactly* the
`ARC` and `IMP` bullet points assigned to this part, and
- the `## VERIFICATION (WHEN)` section carries *exactly*
the `REG` and `CON` bullet points assigned to this part,
all bullet points keeping their original wording, checkbox
state, and type, and no "backmatter" being carried over from
the epic.
For a bullet point which was *split* into fragments, the part
carries *only* its own fragment: the <text/> keeps the
*original* wording of the portion this fragment covers, with
*no* re-interpretation and *no* added scope, and the
`<box/> <type/>:` prefix is kept *unchanged*. Across all
parts, the fragments of a split bullet point *MUST* still
reproduce the original bullet point *completely* and
*without* duplication.
<if condition="<task-content/> does NOT contain a `## VERIFICATION (WHEN)` section heading">
The epic itself deliberately *omits* the `## VERIFICATION
(WHEN)` section, so you *MUST* omit this section (including
its heading) from <part-content/>, too.
</if>
<elseif condition="no `## VERIFICATION (WHEN)` bullet point was assigned to this part">
This part carries *no* verification of its own, so you *MUST*
omit the `## VERIFICATION (WHEN)` section (including its
heading) from <part-content/>, too -- an *empty* section
would violate the plan <format/>, and rule 5 forbids
inventing a bullet point.
</elseif>
2. Call the `ase_task_save(id: "<part-id/>", text:
"<part-content/>", create: true)` tool of the `ase` MCP server -- for
a colliding part with the argument `force: true` instead of
`create`, as `--force` explicitly requested its overwrite -- to persist
the sub-task plan -- this MCP tool call is the *only*
permitted way to persist it, *NEVER* write the plan file
via `Write`/`Edit` or by executing a shell command. If this
call fails because the task already exists (a concurrent
session took the same id), re-identify this part as in step
3.2, replace its <part-id/> in <part-content/>, in the
<part-after/> of all later parts, and in <terminal-parts/>,
and save
again. Do not
output anything related to this MCP tool call except the
following <template/>:
<template>
⧉ **ASE**: ◉ task: **<part-id/>**, ▶ status: **sub-task plan created**
</template>
4. <if condition="<dissect-mode/> is equal `epic` AND <task-group/> is not equal <ase-task-id/>">
*Turn the task into an explicit epic*: call the
`ase_task_load(id: "<ase-task-id/>", tag: true)` tool of the `ase`
MCP server, set the `Group:` frontmatter key of the loaded plan
to <ase-task-id/> (inserting the key at its position in the key
order if absent), change *nothing* else, and save it with the
`ase_task_save(id: "<ase-task-id/>", text: "<epic-content/>",
base: "<tag/>")` tool of the `ase` MCP server, where <tag/> is
the entity tag of the load. As an explicit epic, the task now
implicitly comes `After` all of its parts. Do not output anything
related to these MCP tool calls except the following <template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **turned into epic**
</template>
</if>
5. <if condition="<dissect-mode/> is equal `member`">
*Replace the task by its parts* in the epic <task-group/>,
strictly *after* *all* parts were saved in sub-step 4.3:
1. *Re-wire the successors*: call the `ase_task_list(verbose:
false)` tool of the `ase` MCP server, and for *every* listed
task id <other-id/> which is neither <ase-task-id/> nor a
<part-id/>, call the `ase_task_load(id: "<other-id/>", tag:
true)` tool of the `ase` MCP server. If its `After:` key
lists <ase-task-id/>, replace this entry by the
<terminal-parts/> (dropping duplicates and keeping the order
of the other entries), change *nothing* else, and save it
with the `ase_task_save(id: "<other-id/>", text:
"<other-content/>", base: "<tag/>")` tool of the `ase` MCP
server. Do not output anything related to these MCP tool
calls except the following <template/> per re-wired task:
<template>
⧉ **ASE**: ◉ task: **<other-id/>**, ▶ status: **re-wired to parts**
</template>
2. *Delete the dissected task*: call the
`ase_task_delete(id: "<ase-task-id/>")` tool of the `ase` MCP
server, as its parts now carry its entire content. Do not
output anything related to this MCP tool call except the
following <template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **replaced by parts**
</template>
</if>
6. *Report the overall result* with the following <template/>:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ dissection: **<n/>** parts, ⊂ epic: **<part-group/>**, ▶ status: **task dissected**
</template>
5. **Give Final Hints:**
Finally, give the closing hints by expanding the following (which,
depending on the configured <ase-guidance-level/>, may each expand
into nothing and hence emit no output at all):
<if condition="<getopt-option-dry/> is not equal `true`">
<ase-tpl-hint level="minimal">
Use `/ase-task-id <id>` to switch to one of the created sub-task plans and `/ase-task-implement` to implement it.
</ase-tpl-hint>
</if>
<else>
<ase-tpl-hint level="minimal">
Re-run `/ase-task-dissect` without `--dry` to actually create the reported sub-task plans, optionally with a `<dissect-hint>` argument if the reported split is not the intended one.
</ase-tpl-hint>
</else>
<ase-tpl-hint level="normal">
Use `/ase-task-list` to see the epic plan and all of its sub-task plans side by side.
</ase-tpl-hint>
<ase-tpl-hint level="verbose">
Use `/ase-task-dissect --max-parts <count>` to bound the number of parts, `/ase-task-dissect --force` to overwrite already existing sub-task plans, and `/ase-task-dissect <task-id>: <dissect-hint>` to address another task and steer its split.
</ase-tpl-hint>
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |