Skip to content

rse/ase / plugin/skills/ase-task-dissect

ase-task-dissect

Verified

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

FileKindSize
SKILL.mdskill md18.9 KB
help.mdmarkdown4.9 KB
---
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>
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall