rse/ase / plugin/skills/ase-task-reboot
ase-task-reboot
UnverifiedReboot the current or given task plan by re-creating it from scratch. Use when the user calls to "reboot", "recreate" or "refresh" the "task", "plan", "spec", or "specification".
SKILL.md
View on GitHub---
name: ase-task-reboot
argument-hint: "[--help|-h] [--next|-n <option>[,...]] [--ground|-G] [<id>]"
description: >
Reboot the current or given task plan by re-creating it from scratch.
Use when the user calls to "reboot", "recreate" or "refresh"
the "task", "plan", "spec", or "specification".
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-dialog.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
<purpose name="ase-task-reboot">
Reboot a Task Plan
</purpose>
<expand name="getopt"
arg1="ase-task-reboot"
arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|DRAFT)... --ground|-G --int-reuse-task"
arg3="colon-or-bare">
$ARGUMENTS
</expand>
<objective>
*Reboot* the task plan by crafting it from scratch,
based on the existing `SPECIFICATION (WHAT)`.
</objective>
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-meta.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-ground.md
<expand name="task-plan-only"/>
Procedure
---------
1. **Determine Task:**
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 task id:
<expand name="task-react-id" arg1="ase-task-reboot"></expand>
2. **Determine Operation:**
1. Determine the current task plan content:
<expand name="task-load-content"></expand>
2. <if condition="<task-content/> is 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.
</if>
3. <if condition="the `Status:` frontmatter key of <task-content/> is present and one of the *finished* states of the task lifecycle model <ase-project-task-lifecycle/>: `CLOSED` and `CANCELLED` for `solo` (or absent), `IMPLEMENTED` and `CANCELLED` for `team`, resp. `INTEGRATED` and `CANCELLED` for `enterprise`">
A finished plan cannot start its lifecycle anew, as no
transition leads from a finished state back to the default
state the reboot resets the `Status:` key to, so the save would
be refused only after the entire re-creation work. Set <status/>
to the value of this key. Only output the following <template/>,
directly followed by the hint, and then immediately *STOP*
processing the entire current skill, leaving the plan
*untouched*:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ ERROR: plan with finished status **<status/>** cannot be rebooted
</template>
<ase-tpl-hint level="minimal">
Run `/ase-task-edit` with a new task id to create a new task plan instead.
</ase-tpl-hint>
</if>
3. **Reboot Task Plan:**
1. Start with <instruction></instruction> (set instruction to empty).
Do not output anything.
2. <if condition="the `## SPECIFICATION (WHAT)` section of <task-content/> contains at least one `DOM` or `IFC` bullet-point">
Set <mode>structured</mode>. Extract the <text/> of *every*
`DOM` and `IFC` bullet-point of the `## SPECIFICATION (WHAT)`
section, in their original order, each with its
`- <box/> <type/>:` prefix stripped and its wording kept
*verbatim*. Set <instruction/> to these texts, joined by a
blank line (set instruction to the extracted specification).
The `## DESIGN (HOW)` and `## VERIFICATION (WHEN)` sections
are *deliberately* ignored, as the reboot re-derives them from
scratch.
</if>
3. <if condition="<instruction/> is still empty">
Set <mode>unstructured</mode>. The plan does not follow the
<format/> (or carries no `DOM` or `IFC` bullet-point), so the
reboot has to *file* its entire existing content into the
<format/> instead. Set <instruction/> to the full previous plan
"body" (the second block of <task-content/>, without frontmatter
and backmatter), with its wording kept *verbatim*.
</if>
4. <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
Set <timestamp-created><text/></timestamp-created> (set
timestamp-created to extracted text).
</if>
5. <if condition="<instruction/> is empty or contains only whitespace">
There is nothing to reboot from. Only output the following
<template/> and then immediately *STOP* processing the entire
current skill:
<template>
⧉ **ASE**: ☻ skill: **ase-task-reboot**, ▶ ERROR: empty instruction -- nothing to reboot from
</template>
</if>
6. Only output the following <template/> and continue processing:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<mode/> plan content**, ▶ status: **instruction given**
</template>
7. <expand name="task-ground-plan" arg1=""/>
<if condition="<getopt-option-ground/> is equal `true`">
Ground the plan in the sections re-derived from scratch, where
<dimensions/> is `HOW WHEN` if <mode/> is `structured` (as the
`## SPECIFICATION (WHAT)` section is seeded verbatim), or
`WHAT HOW WHEN` if <mode/> is `unstructured`:
<expand name="ground"
arg1="the instruction in <instruction/>"
arg2=""
arg3="<dimensions/>"></expand>
</if>
Create a new plan from scratch and store the result as
<task-content/> by closely following the defined plan format
<format/> and injecting into it all the information from
the <instruction/>, all decisions you derived from the
<instruction/>, the grounding in the project, and the grounding
facts <ground-facts/> (if any, preferred over the world knowledge
of the model), where:
- <if condition="<mode/> is `structured`">
the `## SPECIFICATION (WHAT)` section is *seeded* by the
extracted `DOM` and `IFC` bullet-points, re-phrased and
re-structured where the <instruction/> demands it, and the
`## DESIGN (HOW)` and `## VERIFICATION (WHEN)` sections
are *re-derived* from scratch,
</if>
- <if condition="<mode/> is `unstructured`">
*all* existing content of the <instruction/> is *filed* into
the `## SPECIFICATION (WHAT)`, `## DESIGN (HOW)`, and
`## VERIFICATION (WHEN)` sections: classify each existing
statement, prose paragraph, bullet, or list item by its
nature into a `DOM`, `IFC`, `ARC`, `IMP`, `REG`, or `CON`
bullet-point, keep its wording as *verbatim* as the
bullet-point <text/> conventions allow, *never* drop a
distinct statement, and *add* missing `DOM`/`IFC`,
`ARC`/`IMP`, and `REG`/`CON` bullet-points *derived* from
the existing content where a section would otherwise stay
empty,
</if>
- every bullet-point starts in the `[ ]` todo state,
- the `Status:` frontmatter key is *reset* to the *default*
state of the task lifecycle model
<ase-project-task-lifecycle/>, as the rebooted plan starts
its lifecycle anew,
- the frontmatter keys `Group:`, `Phase:`, `After:`, `Assignee:`,
`Kind:`, and `Tags:` are taken over from the previous plan *verbatim*
where present, except that all `grilled:` tags
are *dropped* from `Tags:` (the whole key is dropped if no
other tag remains), as the grilled plan content is gone,
- the `Kind:` frontmatter key, if *absent* in the previous plan,
is *created* by *inferring* the kind of change from the
*re-created* plan content according to the plan <format/>
(defaulting to `CRAFTING`),
- the frontmatter keys `Source:`, `Changeset:`, and `Target:`
are *dropped*, so they are *reset* to their configured
defaults according to the plan <format/>, as the rebooted
plan starts its change set flow anew, and
- the entire "backmatter" of the previous plan is passed
through *verbatim*.
8. <expand name="task-save-content" arg1="plan rebooted"></expand>
4. **Decide Next Step:**
1. *Determine next step*:
<expand name="task-next-select"
arg1="ase-task-reboot"
arg2="DONE|EDIT|IMPLEMENT|DRAFT">
Next Step: How would you like to proceed with the plan?
DONE: Stop processing.
EDIT: Hand off plan to editing.
IMPLEMENT: Hand off plan to implementation.
DRAFT: Hand off plan to implementation drafting.
</expand>
2. Check the tool <result/> and dispatch accordingly:
- If <result/> is `DONE` or `CANCEL`:
Only output the following <template/> and then *STOP*.
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan rebooted -- done**
</template>
- If <result/> is `EDIT`:
Set <edit-args>--ground</edit-args> if <getopt-option-ground/>
is `true`, or set <edit-args></edit-args> (empty) otherwise.
<expand name="task-next-handoff" arg1="ase-task-edit"
arg2="plan rebooted -- hand-off to edit"
arg3="<edit-args/>"></expand>
- If <result/> is `IMPLEMENT`:
<expand name="task-next-handoff" arg1="ase-task-implement"
arg2="plan rebooted -- hand-off to implementation"></expand>
- If <result/> is `DRAFT`:
<expand name="task-next-handoff" arg1="ase-task-implement"
arg2="plan rebooted -- hand-off to implementation draft"
arg3="--draft"></expand>
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 |