/ase-task-reboot

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 `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="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: **<instruction/>**, ▶ status: **instruction given** </template>

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/>, 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:`, `Kind:`,

`Tags:`, and `Branch:` are taken over from the previous plan *verbatim* where present, except that all `grilled:` tags