Ase Task Preflight

---
name: ase-task-preflight
argument-hint: "[--help|-h] [--next|-n <option>[,...]] [<id>]"
description: >
    Preflight the implementation of current or given task plan.
    Use when the user calls to "preflight", "dry-run" or "test-drive"
    the "task", "plan", "spec", or "specification".
user-invocable: true
disable-model-invocation: false
effort: xhigh
---

@${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-preflight">
Preflight a Task Plan
</purpose>

<expand name="getopt"
    arg1="ase-task-preflight"
    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT)... --int-reuse-task">
    $ARGUMENTS
</expand>

<objective>
*Preflight* the implementation of a task plan by creating a draft
for a corresponding, *complete source code change set*.
</objective>

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-tenets.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-code.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-preflight"></expand>

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

    3.  Internalize the tenets stated by the plan:

        <expand name="code-tenets-from-plan"></expand>

3.  **Create Implementation Draft:**

    1.  Perform a *preflight* of the *implementation* of <task-content/> by creating a
        draft for a corresponding, *complete artifact change set*
        which *would* fully implement the task plan <task-content/>. Store
        this artifact change set in *unified diff* format in <unified-diff/>.

        Create this draft with the *same rigor* as the final
        implementation of the companion skill `ase-task-implement`,
        because that skill later takes the draft over *1:1* -- the user
        is assumed to review the draft in between. Hence *read* the
        current content of *every* artifact the draft touches before
        drafting its hunks, so all context lines match the artifacts
        *exactly* and the diff would apply *cleanly*, and honor the
        task plan and the internalized tenets just as the final
        implementation would. Only the actual modification of the
        artifacts and the verification phase are deferred to
        `ase-task-implement`.

    2.  Append this artifact change set <unified-diff/> to the end
        of the <task-content/> with the following <template/>. If a section
        named `##  IMPLEMENTATION DRAFT` already exists from a
        previous run of this skill, *replace* this entire existing
        section.

        Set <fence/> to a run of backtick characters *one longer* than
        the longest backtick run occurring anywhere inside
        <unified-diff/>, but to at least three, so a diff which itself
        carries fenced code blocks (e.g. one over Markdown artifacts)
        cannot terminate the block prematurely.

        <template>

        ##  IMPLEMENTATION DRAFT

        <fence/>text
        <unified-diff/>
        <fence/>

        </template>

    3.  Update <timestamp-modified/> with the current time in
        ISO-style format, which has to be determined by calling the
        `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
        MCP server and using the `text` field of its response. Update
        the `Modified: ...` frontmatter key of <task-content/> with the
        new <timestamp-modified/> value, *creating* the whole key at its
        position in the key order of the plan <format/> if the plan does
        not carry it yet.
        Do not output anything.

        Additionally *add* the value `preflighted` to the `Properties:`
        frontmatter key of <task-content/> if it is still absent, keeping
        all already present values and *creating* the whole key (with the
        single value `preflighted`) if the plan carries none. Do not
        output anything.

    4.  Finally, call the `ase_task_save(id: "<ase-task-id/>",
        text: "<task-content/>")` tool of the `ase` MCP server to save the updated
        task plan content. This `ase_task_save` MCP tool call is the
        *only* permitted way to persist the plan -- *NEVER* write the
        plan file via `Write`/`Edit` or by executing a shell command.
        Do not output anything related to this MCP tool call
        except the following <template/>:

        <template>
        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated**
        </template>

4.  **Decide Next Step:**

    1.  *Determine next step*:

        <expand name="task-next-select"
            arg1="ase-task-preflight"
            arg2="DONE|EDIT|IMPLEMENT">
            Next Step: How would you like to proceed with the plan?
            DONE: Stop processing.
            EDIT: Hand processing off to editing.
            IMPLEMENT: Hand processing off to implementation.
        </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 updated -- done**
            </template>

        -   If <result/> is `EDIT`:
            <expand name="task-next-handoff" arg1="ase-task-edit"
                arg2="plan updated -- hand-off to edit"></expand>

        -   If <result/> is `IMPLEMENT`:
            <expand name="task-next-handoff" arg1="ase-task-implement"
                arg2="plan updated -- hand-off to implementation"></expand>