ase-task-reboot · diff
git:20260813.5985917 to git:20260914.a549cab
63 added, 33 removed. Audit A to A.
---
name: ase-task-reboot
argument-hint: "[--help|-h] [--next|-n <option>[,...]] [<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|PREFLIGHT)... --int-reuse-task">
$ARGUMENTS
</expand>
<objective>
*Reboot* the task plan by crafting it from scratch,
- based on the existing *WHAT* and *WHY*.
+ based on the existing `SPECIFICATION (WHAT)`.
</objective>
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
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-code-resolve`,
`ase-code-refactor`, `ase-code-craft`, or `ase-task-edit` skills
first to create a task plan. Then immediately stop processing
this skill.
</if>
3. **Reboot Task Plan:**
1. Start with <instruction></instruction> (set instruction to empty).
Do not output anything.
- 2. <if condition="<task-content/> contains neither '- **WHAT**:' nor '- **WHY**:'">
- Set <instruction><task-content/></instruction> (set instruction to task content).
- </if>
-
- 3. <if condition="<task-content/> contains '- **WHAT**: <text/>'">
- Set <instruction><text/></instruction> (set instruction to extracted text).
- </if>
-
- 4. <if condition="<task-content/> contains '- **WHY**: <text/>' and <instruction/> is empty">
- Set <instruction><text/></instruction> (set instruction to extracted text).
+ 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>
- 5. <if condition="<task-content/> contains '- **WHY**: <text/>' and <instruction/> is NOT empty">
- Set <instruction><instruction/>, BECAUSE <text/></instruction>
- (append extracted text to instruction).
+ 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>
- 6. <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
+ 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>
- 7. <if condition="<instruction/> is empty or contains only whitespace">
- The WHAT/WHY extraction yielded no usable text (e.g. a
- `- **WHAT**:` line existed but captured empty text, so the
- whole-content fallback above did not fire). Fall back to the
- full previous plan content: set <instruction><task-content/></instruction>
- (set instruction to task content).
- <if condition="<instruction/> is still 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:
+ 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>
+ <template>
+ ⧉ **ASE**: ☻ skill: **ase-task-reboot**, ▶ ERROR: empty instruction -- nothing to reboot from
+ </template>
</if>
- 8. Only output the following <template/> and continue processing:
+ 6. Only output the following <template/> and continue processing:
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
</template>
- 9. Create a new plan from scratch and store the result as
+ 7. 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/> and all decisions you derived from the
- <instruction/>.
+ <instruction/>, where:
- 10. <expand name="task-save-content" arg1="plan rebooted"></expand>
+ - <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:`, `Kind:`,
+ `Tags:`, and `Branch:` 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, 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|PREFLIGHT">
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.
PREFLIGHT: Hand off plan to pre-flighting.
</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`:
<expand name="task-next-handoff" arg1="ase-task-edit"
arg2="plan rebooted -- hand-off to edit"></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 `PREFLIGHT`:
<expand name="task-next-handoff" arg1="ase-task-preflight"
arg2="plan rebooted -- hand-off to pre-flight"></expand>