ase-task-preflight · diff

git:20260810.e02a375 to git:20260813.5985917

3 added, 4 removed. Audit A to A.

---

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

Preflight a Task Plan

</purpose>

<expand name="getopt"

arg1="ase-task-preflight"

arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT)... --int-reuse-task">

$ARGUMENTS

</expand>

*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:

2. **Determine Operation:**

1. Determine the current task plan content:

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:

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.

## IMPLEMENTATION DRAFT

<fence/>text

<unified-diff/>

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

- Calculate the number of words <words/> of

- <task-content/>. Do not output anything related to this MCP tool call

+ Do not output anything related to this MCP tool call

except the following <template/>:

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

+ ⧉ **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*.

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

+ ⧉ **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>