/ase-task-dissect

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"> $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=" <instruction/> matches the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*:?$` "> The lone token is the *task id* (with an optional and ignored trailing `:`), never a hint. Set <ase-task-id><instruction/></ase-task-id> (set task id to instruction, with any trailing `:` stripped) and <instruction></instruction> (set instruction empty), 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>

<elseif condition=" <instruction/> has the format `<id/>: <text/>` where <id/> matches the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$` "> Set <instruction><text/></instruction> (set instruction to text) and <ase-task-id><id/></ase-task-id> (set task id to 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> </elseif>

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