Skip to content

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

ase-task-dissect

Unverified

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

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

$ARGUMENTS

@${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 initially, with any leading and trailing whitespace stripped. Inherit the always existing from the current context. Inherit the always existing from the current context. Do not output anything.

    2. React on the task id:

      The lone token is the task id (with an optional and ignored trailing :), never a hint. Set (set task id to instruction, with any trailing : stripped) and (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 :

      Set (set instruction to text) and (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 :

    3. React on the dissection hint:

      Set (set the dissection hint to the remaining instruction), with any leading and trailing whitespace stripped.

  2. Determine Operation:

    1. Determine the current task plan content:

    2. If the 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 : set to the value of its Group: key and to the list of task ids of its After: key (each empty if the key is absent).

  3. Dissect Task Plan:

    1. Derive the parts of the epic:

      <expand name="dissect-derive" arg1="ase-task-dissect" arg2="" arg3=""

      the individual bullet points of the ## SPECIFICATION (WHAT), ## DESIGN (HOW), and ## VERIFICATION (WHEN) sections of the loaded plan

      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 , in their derived order, remember its as its and call the ase_task_newid(title: "<scope/>", proposal: "<part-id/>", taken: [ <previous/> ]) tool of the ase MCP server, where lists the already re-identified of all preceding parts (as the tool reserves ids for scheme seq only), and replace the of the part with the id field of its response -- you MUST NEVER assemble such an id yourself. Do not output anything related to these MCP tool calls.

      Then derive the dependencies of the parts: for every part, set to the 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 is a root part: set its to , so it inherits the predecessors of the dissected task. Finally, set to the of all parts which no other part lists in its .

    3. Report the parts:

  4. Materialize Sub-Task Plans:

    The body of the dissected plan of 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. Detect target collisions, strictly before writing anything:

      Call the ase_task_list(verbose: false) tool of the ase MCP server and set to the id fields of the returned tasks array. Do not output anything related to this MCP tool call. Set to all of which are already present in (as each itself was re-identified to a free id in step 3.2).

      Directly after this , and before stopping, give the corrective hint by expanding the following (which, depending on the configured , may expand into nothing and hence emit no output at all):

    2. 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 and information of all parts.

      Then, for every part in , in their derived order:

      1. Compose a complete task plan by closely following the plan , where:

        • the is ,
        • the is the default state of the task lifecycle model , as every part is a newly created plan,
        • the Group: key carries , so all parts are grouped under the same epic,
        • the After: key carries , formatted as a comma-and-space-separated list, and is omitted if 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 is derived from the part's ,
        • 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 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.

      2. Call the ase_task_save(id: "<part-id/>", text: "<part-content/>", create: true) tool of the ase MCP server -- for a part of 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 in , and save again. Do not output anything related to this MCP tool call except the following :

      1. Re-wire the successors: call the ase_task_list(verbose: false) tool of the ase MCP server, and for every listed task id which is neither nor a , call the ase_task_load(id: "<other-id/>", tag: true) tool of the ase MCP server. If its After: key lists , replace this entry by the (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 per re-wired task:

      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 :

    3. Report the overall result with the following :

  5. Give Final Hints:

    Finally, give the closing hints by expanding the following (which, depending on the configured , may each expand into nothing and hence emit no output at all):

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: 196kUpdated 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: 192kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 192kUpdated 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: 192kUpdated Claude CodeCodexVerifiedInstall