/ase-task-integrate

name: ase-task-integrate
argument-hint: "[--help|-h] [--next|-n <option>[,...]] [--worktree|-w <name>] [--changeset|-c <changeset>] [--draft|-d] [--target|-t <target>] [--mode|-m merge|rebase|squash] [--no-cleanup|-K] [--stateless|-S] [<id>]"
description: >
    Integrate the change set or implementation draft of the current or given
    task plan into its target. Use when the user calls to "deliver" or
    "apply" the change set or draft of the "task" or "plan". For merging
    a plain Git branch, use `ase-repo-merge` instead.
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-integrate"> Integrate a Task Change Set </purpose>

<expand name="getopt" arg1="ase-task-integrate" arg2="--next|-n=(none|DONE|DELETE)... --worktree|-w= --changeset|-c= --draft|-d --target|-t= --mode|-m=(merge|rebase|squash) --no-cleanup|-K --stateless|-S --int-reuse-task"> $ARGUMENTS </expand>

<objective> *Integrate* the change set of the task plan from its *changeset* location into its *target* through a Git merge. </objective>

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md @${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md @${CLAUDE_SKILL_DIR}/../../meta/ase-common-changeset.md

<define name="integrate-temp-remove"> If <temp-dir/> is not empty, remove the temporary worktree and branch by running the commands `git worktree remove --force "<temp-dir/>"`, `git worktree prune`, and `git branch -D "<temp-branch/>"` (taken exactly as given), ignoring any failure, and set <temp-dir></temp-dir> (empty). Do not output anything. </define>

Procedure ---------

1. **Determine Task:**

1. Set <instruction><getopt-arguments/></instruction> initially, with any leading and trailing whitespace stripped, and set <temp-dir></temp-dir> (empty). 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-integrate"></expand>

3. Resolve the draft shorthand: if <getopt-option-draft/> is `true` and <getopt-option-changeset/> is not empty, only output the following <template/> and then immediately *STOP* processing the entire current skill:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ ERROR: options `--draft` and `--changeset` are mutually exclusive </template>

Otherwise, if <getopt-option-draft/> is `true`, set <getopt-option-changeset>attachment:draft</getopt-option-changeset>, so the *implementation draft* in the attachment `draft` of the plan is delivered. Do not output anything.

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, and `ase-task-implement` to create its change set. Then immediately stop processing this skill.

3. <if condition="<getopt-option-stateless/> is not equal `true`, the task lifecycle model <ase-project-task-lifecycle/> is `solo`, and the `Status:` frontmatter key of <task-content/> is present and not equal `OPEN`"> Only an `OPEN` plan can be integrated in the `solo` model, as only `OPEN` transitions directly into `CLOSED`. 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 and the artifacts *untouched*:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ ERROR: plan with status **<status/>** cannot be integrated (expected **OPEN**) </template>

<ase-tpl-hint level="minimal"> Run `/ase-task-status OPEN` first to re-open the plan. </ase-tpl-hint> </if>

3. **Prepare Changeset and Target:**

The *changeset* (location of the change set) and the *target* (place of integration) are controlled by the `Changeset:` and `Target:` frontmatter keys of the plan, which the `--changeset` and `--target` options override *ad-hoc* without changing the plan. The `worktree` value of the changeset refers to the *context worktree*, selected by the `--worktree` option, the `worktree` value of the target (and of the source it may refer to) to the *origin working copy* the skill was started in (both are the same without `--worktree`). An integration never creates a context worktree.

1. Set <task-changeset/> to <getopt-option-changeset/> if it is not empty, otherwise to the value of the `Changeset:` frontmatter key of <task-content/>, or to the configured default <ase-project-task-default-changeset/> if the key is absent, and parse it:

<expand name="changeset-value" arg1="Changeset" arg2="<task-changeset/>" arg3="`worktree`, `branch`, `attachment`" arg4="◉ task: **<ase-task-id/>**"></expand>

Set <changeset-type><value-type/></changeset-type> and <changeset-name><value-name/></changeset-name>.

2. <if condition="<getopt-option-worktree/> is not empty and <changeset-type/> is not `worktree`"> The context worktree serves the `worktree` changeset only, so a `branch:` or `attachment:` changeset would leave it unused (e.g. on a mistyped option). Only output the following <template/> and then immediately *STOP* processing the entire current skill