@rse/ase 1.0.7 → 2.0.1

package/dst/ase-agent-definition-api.d.ts

@@ -0,0 +1,184 @@
+type Many<T> = T | T[];
+export type AgentType = "phase" | "request";
+export type AgentWorkdir = "project" | "source" | "changeset" | "changeset-read" | "target";
+export type AgentCriterion = "exit" | "clean" | "changed" | "verdict" | "attachment" | "status";
+export interface AgentParam {
+    desc?: string;
+    default?: string | number | boolean;
+    required?: boolean;
+    allow?: Many<string>;
+}
+export interface AgentDefinition {
+    definition?: string;
+    title?: string;
+    description?: string;
+    params?: Record<string, AgentParam | string | number | boolean>;
+    type?: AgentType;
+    workdir?: AgentWorkdir;
+    lifecycle?: Many<string>;
+    serial?: boolean;
+    unclaimed?: boolean;
+    state?: {
+        incoming?: Many<string>;
+        activity?: string;
+        success?: string;
+        failure?: string;
+        phase?: string;
+        passed?: string;
+        verdict?: Many<string>;
+    };
+    tag?: {
+        name?: string;
+        success?: string;
+        failure?: string;
+        require?: Many<string>;
+        exclude?: Many<string>;
+        retry?: boolean;
+    };
+    assign?: {
+        name?: string;
+        required?: boolean;
+        success?: string;
+        failure?: string;
+    };
+    request?: {
+        name?: string;
+        done?: string;
+    };
+    prompt?: {
+        skill?: string;
+        args?: string;
+        text?: string;
+        file?: string;
+    };
+    prepare?: {
+        run?: Many<string>;
+    };
+    success?: {
+        criterion?: Many<AgentCriterion>;
+        match?: Many<string>;
+    };
+    verdict?: {
+        label?: string;
+        allow?: Many<string>;
+    };
+    attach?: {
+        output?: string;
+        expect?: string;
+        skip?: string;
+        changeset?: string;
+    };
+    finish?: {
+        commit?: boolean;
+        success?: string;
+        failure?: string;
+    };
+    hooks?: AgentHooks;
+}
+export type AgentDefinitionExport = AgentDefinition | (() => AgentDefinition | Promise<AgentDefinition>);
+export interface AgentHookTask {
+    readonly id: string;
+    readonly title: string;
+    readonly status: string;
+    readonly keys: Readonly<Record<string, string>>;
+    readonly tags: readonly string[];
+}
+export interface AgentHookFlow {
+    readonly type: string;
+    readonly name: string;
+}
+export interface AgentHookAttachment {
+    readonly type: string;
+    readonly desc: string;
+    readonly data?: string;
+}
+export type AgentHookLevel = "error" | "warning" | "info";
+export interface AgentHookExec {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface AgentHookAttach {
+    readonly kind: string;
+    readonly mime?: string;
+    readonly desc?: string;
+    readonly data: string;
+    readonly replace?: boolean;
+}
+export interface AgentHookUpdate {
+    keys?: Readonly<Record<string, string | null>>;
+    tags?: {
+        readonly add?: readonly string[];
+        readonly remove?: readonly string[];
+    };
+    attach?: readonly AgentHookAttach[];
+}
+export interface AgentHookContext {
+    readonly agent: {
+        readonly name: string;
+        readonly kind: string;
+        readonly mode: string;
+        readonly tag: string;
+    };
+    readonly params: Readonly<Record<string, string>>;
+    readonly lifecycle: {
+        readonly name: string;
+        readonly states: readonly string[];
+    };
+    readonly signal: AbortSignal;
+    flow(task: AgentHookTask, key: "Source" | "Changeset" | "Target"): AgentHookFlow | null;
+    attachments(task: AgentHookTask | string): Promise<readonly AgentHookAttachment[]>;
+    plan(task: AgentHookTask | string): Promise<string | null>;
+    task(id: string): Promise<AgentHookTask | null>;
+    tasks(): Promise<readonly AgentHookTask[]>;
+    update(task: AgentHookTask | string, change: AgentHookUpdate): Promise<boolean>;
+    exec(cmd: string, args?: readonly string[], options?: {
+        readonly cwd?: string;
+        readonly env?: Readonly<Record<string, string>>;
+        readonly input?: string;
+    }): Promise<AgentHookExec>;
+    log(level: AgentHookLevel, message: string): void;
+}
+export interface AgentHookJob {
+    readonly dir: string;
+    readonly dirs: readonly string[];
+    readonly sourceDir: string;
+    readonly changesetWorktree: string;
+    readonly request: string;
+}
+export type AgentHookPrompt = {
+    readonly skill: string;
+    readonly args: string;
+} | {
+    readonly text: string;
+};
+export interface AgentHookResult {
+    readonly ok: boolean;
+    readonly output: readonly string[];
+    readonly verdict: string;
+}
+export interface AgentHookOutcome {
+    readonly success: boolean;
+    readonly reasons: readonly string[];
+    readonly result: AgentHookResult;
+}
+export interface AgentHookSettlement {
+    readonly state?: string;
+    readonly tag?: string | null;
+    readonly assignee?: string;
+}
+type Async<T> = T | Promise<T>;
+export interface AgentHooks {
+    start?: (ctx: AgentHookContext) => Async<void>;
+    order?: (tasks: readonly AgentHookTask[], ctx: AgentHookContext) => Async<readonly (AgentHookTask | string)[]>;
+    passes?: (pred: AgentHookTask, succ: AgentHookTask, ctx: AgentHookContext) => boolean | undefined;
+    ready?: (task: AgentHookTask, ctx: AgentHookContext) => Async<boolean | string>;
+    prepare?: (task: AgentHookTask, job: AgentHookJob, ctx: AgentHookContext) => Async<void>;
+    prompt?: (task: AgentHookTask, prompt: AgentHookPrompt, job: AgentHookJob, ctx: AgentHookContext) => Async<AgentHookPrompt | string | undefined>;
+    verdict?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<string | undefined>;
+    success?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<boolean | string>;
+    settle?: (task: AgentHookTask, outcome: AgentHookOutcome, ctx: AgentHookContext) => Async<AgentHookSettlement | undefined>;
+    finish?: (task: AgentHookTask, outcome: AgentHookOutcome, job: AgentHookJob, ctx: AgentHookContext) => Async<void>;
+    stop?: (ctx: AgentHookContext) => Async<void>;
+}
+export {};

package/dst/ase-agent-definition-api.js

@@ -0,0 +1,6 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+export {};

package/dst/ase-agent-definition-builtin/condenser.js

@@ -0,0 +1,42 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+/*  agent "ase agent condenser", processing a plan only on explicit request,
+    i.e., once a human assigned the task to the condenser (by its name)  */
+export default {
+    kind: "condenser",
+    description: "Condense the plans of tasks in the \"Planning\" phase of the \"enterprise\" task lifecycle " +
+        "model on explicit request: claim every \"DRAFTED\" task explicitly assigned to the " +
+        "condenser (by its name) into \"PLANNING\", " +
+        "compress the wording of its plan via the headless agent tool and the \"ase-task-condense\" " +
+        "skill, and put it back into \"DRAFTED\" and unassign it (or put it back into \"DRAFTED\" " +
+        "with its previous assignee on interrupt), logging to stdout and to the \"agent\" " +
+        "attachment of the task",
+    modeDesc: "",
+    mode: "condense",
+    modes: {
+        /*  compress the wording of the plan of a task, where the skill leaves the task in
+            "PLANNING", so the agent puts it back into "DRAFTED", and where the task is untagged
+            and unassigned afterwards, so it is guarded by its assignment only and hence condensed
+            again once a human assigns it to the condenser again, and where the processing
+            succeeded only if the agent tool succeeded and the skill reported no error (as the
+            agent tool still exits successfully then), including on an already condensed plan, and
+            where the task waits for no predecessors (see the rebooter)  */
+        condense: {
+            title: "Condense the plans of assigned tasks",
+            description: "Claims every DRAFTED task explicitly assigned to the condenser into PLANNING. Compresses " +
+                "the wording of its plan via the ase-task-condense skill, puts it back into DRAFTED, and " +
+                "unassigns it, so assigning it to the condenser again requests another condensing.",
+            type: "phase",
+            lifecycle: "enterprise",
+            workdir: "project",
+            state: { incoming: "DRAFTED", activity: "PLANNING", success: "DRAFTED", failure: "DRAFTED" },
+            tag: { success: "none", failure: "none" },
+            assign: { required: true },
+            prompt: { skill: "ase-task-condense", args: "--next DONE {id}" },
+            success: { criterion: ["exit", "clean"] }
+        }
+    }
+};

package/dst/ase-agent-definition-builtin/editor.js

@@ -0,0 +1,45 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+/*  agent "ase agent editor"  */
+export default {
+    kind: "editor",
+    description: "Process the edit requests of tasks in any task lifecycle model, as requested with key " +
+        "\"E\" on the task board: claim every task tagged with \"ase-agent-editor:pending\" " +
+        "(except in an activity status, until it changes) by turning its oldest \"edit\" " +
+        "attachment into \"edit-running\" and assigning the task to the agent (keeping all " +
+        "other agents off it), edit its plan by the prompt of the request via the headless " +
+        "agent tool and the \"ase-task-edit\" skill (grounded in its \"Source:\", a " +
+        "\"branch:\" one checked out in a temporary Git worktree, and saved only if not " +
+        "changed meanwhile), restore its previous assignee, and remove the request if the plan " +
+        "was changed (else turn it into \"edit-failed\", or back into \"edit\" on interrupt), " +
+        "logging to stdout and to the \"agent\" attachment of the task",
+    modeDesc: "",
+    mode: "edit",
+    modes: {
+        /*  edit the plan of the task by the prompt of the request in the working copy,
+            grounded in the "Source:" of the task: a "worktree" one in the working copy
+            itself, and a "branch:" one in a temporary, detached Git worktree of the
+            branch (passed to the skill and the agent tool), which is removed afterwards,
+            where the processing succeeded only if the plan content changed since the
+            claim and the skill reported no error  */
+        edit: {
+            title: "Edit task plans by the prompts of edit requests",
+            description: "Claims every task with a pending edit request (requested with key E on the task boards) " +
+                "in any task lifecycle model and in any status except an activity one. Edits its plan by " +
+                "the prompt of the request via the ase-task-edit skill (grounded in the Source: of the " +
+                "task), restores its previous assignee, and removes the request if the plan was changed, " +
+                "else marks the request as failed.",
+            type: "request",
+            workdir: "source",
+            request: { name: "edit", done: "edited" },
+            prompt: {
+                skill: "ase-task-edit",
+                args: "--plan REFINE --next DONE{?source-dir: --int-source-dir \"{source-dir}\"} {id}: {prompt}"
+            },
+            success: { criterion: ["clean", "changed"] }
+        }
+    }
+};

package/dst/ase-agent-definition-builtin/estimator.js

@@ -0,0 +1,98 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import { parseEffort } from "../ase-task-format.js";
+/*  whether a task carries a valid effort estimation (its "Effort" key), as the task store
+    drops a stale one (whose content hash no longer matches the plan body) on loading
+    and listing, so a loaded task carries a well-formed one only if it is valid  */
+const estimated = (task) => parseEffort(task.keys.Effort ?? "") !== null;
+/*  whether a task awaits its effort estimation: it carries no valid effort estimation yet,
+    it is no explicit epic (a task being its own group, whose effort is the sum of its
+    members), and its plan is not empty (as both are skipped by the skill), where this is
+    also the condition the implementer waits on (see its parameter "effort-wait")  */
+export const estimable = async (task, ctx) => !estimated(task) && (task.keys.Group ?? "").trim() !== task.id
+    && ((await ctx.plan(task)) ?? "").trim() !== "";
+/*  the estimation succeeded only once the task carries a valid effort
+    estimation, as the skill reports a failed estimation without an error  */
+const succeeded = async (task, ctx) => {
+    const current = await ctx.task(task.id);
+    return current !== null && estimated(current) ? true : "task carries no valid \"Effort\" key";
+};
+/*  agent "ase agent estimator"  */
+export default {
+    kind: "estimator",
+    description: "Estimate the effort of tasks in any task lifecycle model: pick every task in \"PLANNED\" " +
+        "(adapted onto the task lifecycle model, i.e., \"PLANNING\" for \"team\" and \"OPEN\" for " +
+        "\"solo\"), without tag \"ase-agent-estimator\", without a valid \"Effort\" key, with a " +
+        "non-empty plan, and which is no explicit epic, without claiming it (so its status and its " +
+        "assignee are never changed and no other agent is kept off it), estimate its effort via the " +
+        "headless agent tool and the \"ase-task-estimate\" skill (which writes just its \"Effort\" key " +
+        "in a conditional save), and tag it with \"ase-agent-estimator\" only if it carries no valid " +
+        "\"Effort\" key afterwards (so it is not picked again) (\"--mode phase\", intended for the " +
+        "final estimation of the planned tasks), or process the \"estimate\" requests of tasks in any " +
+        "unfinished status (e.g. \"DRAFTED\"), as requested with key \"R\" on the task board, by " +
+        "claiming the task like the editor agent and re-estimating its effort even if it carries a " +
+        "valid one (\"--mode request\", intended for dry-runs, i.e., provisional estimations of plans " +
+        "still in progress), logging to stdout and to the \"agent\" attachment of the task",
+    modeDesc: "\"phase\" for the final estimation of the unestimated tasks in \"PLANNED\" automatically, or " +
+        "\"request\" for dry-runs, (re-)estimating the tasks in any unfinished status on request",
+    mode: "phase",
+    modes: {
+        /*  estimate the effort of the task in the project root, where the task is processed
+            unclaimed, as the skill saves just the "Effort" key conditionally (retried on a
+            concurrent change, e.g. by a claim of another agent), and where an estimated task
+            is left untagged, as its valid "Effort" key itself guards it (see the hook "ready"),
+            so it is estimated again once its plan content changed (as the task store drops its
+            then stale "Effort" key), while a task not estimated is tagged, so it is not picked
+            again and again  */
+        phase: {
+            title: "Estimate the effort of unestimated planned tasks",
+            description: "Picks every PLANNED task without a valid Effort: key, with a non-empty plan, and which is " +
+                "no explicit epic, without claiming it (so its status and its assignee stay untouched). " +
+                "Estimates its effort as a T-shirt size via the ase-task-estimate skill, which stores just " +
+                "its Effort: key, and tags it only if it is still unestimated afterwards, so it is not " +
+                "picked again. Intended for the final estimation of the planned tasks.",
+            type: "phase",
+            unclaimed: true,
+            workdir: "project",
+            state: { incoming: "PLANNED" },
+            tag: { name: "ase-agent-estimator", success: "none" },
+            prompt: { skill: "ase-task-estimate", args: "{id}" },
+            success: { criterion: ["exit", "clean"] },
+            hooks: {
+                /*  estimate only a task awaiting its effort estimation  */
+                ready: (task, ctx) => estimable(task, ctx),
+                /*  the estimation succeeded only with a valid effort estimation  */
+                success: (task, _result, ctx) => succeeded(task, ctx)
+            }
+        },
+        /*  estimate the effort of the task of an "estimate" request in the project root, in
+            any unfinished status (e.g. "DRAFTED", where the phase mode never picks it), where
+            the task is claimed like by the editor agent, and where the estimation is forced,
+            as the request explicitly asks for it even if the task carries a valid one, and
+            where the prompt of the request is ignored (and the criterion "changed" is not
+            used, as a re-estimation of the same size leaves the plan content unchanged),
+            and where the success additionally requires the reported status of a stored
+            estimation, as the hook "success" alone also passes on the old, still valid
+            effort estimation left untouched by a failed re-estimation  */
+        request: {
+            title: "Re-estimate the effort of tasks on request",
+            description: "Claims every task with a pending estimate request (requested with key R on the task " +
+                "boards) in any unfinished status. Re-estimates its effort as a T-shirt size via the " +
+                "ase-task-estimate skill, even if it already carries a valid Effort: key (ignoring the " +
+                "prompt of the request), restores its previous assignee, and removes the request on success. " +
+                "Intended for dry-runs, i.e., provisional estimations of plans still in progress.",
+            type: "request",
+            workdir: "project",
+            request: { name: "estimate", done: "estimated" },
+            prompt: { skill: "ase-task-estimate", args: "--force {id}" },
+            success: { criterion: ["exit", "clean"], match: ["status:\\W*effort estimated\\b"] },
+            hooks: {
+                /*  the estimation succeeded only with a valid effort estimation  */
+                success: (task, _result, ctx) => succeeded(task, ctx)
+            }
+        }
+    }
+};

package/dst/ase-agent-definition-builtin/implementer.js

@@ -0,0 +1,121 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import { estimable } from "./estimator.js";
+/*  the parameters of the implementer: whether a task is claimed only once the estimator
+    is done with it (default), to be disabled when no estimator agent is used  */
+const params = {
+    "effort-wait": {
+        desc: "whether to wait for the effort estimation of a task by the agent \"estimator\"",
+        default: "true",
+        allow: ["true", "false"]
+    }
+};
+/*  with the parameter "effort-wait", a task is claimed only once the estimator is done
+    with it, i.e., once it no longer awaits its effort estimation, or once the estimator
+    failed on it (and hence tagged it, so it is not estimated again), as the estimator
+    processes the "PLANNED" tasks unclaimed and would else race against the implementer,
+    which, if claiming a task first, would keep it from being estimated at all  */
+const ready = async (task, ctx) => ctx.params["effort-wait"] !== "true"
+    || task.tags.some((tag) => tag === "ase-agent-estimator" || tag.startsWith("ase-agent-estimator:"))
+    || !(await estimable(task, ctx))
+    || "its effort estimation by the agent \"estimator\"";
+/*  a predecessor passed the implementation phase for its successor only once its change
+    set is contained in the "Source:" of the successor, from which the successor is
+    implemented resp. drafted, i.e., once integrated (and its integrated target branch
+    published, i.e., not still held by the integrator or failed there), or, for a
+    successor stacked onto it (with the "branch:" changeset of the predecessor as its
+    "Source:"), already once implemented (and its changeset branch committed and
+    published, i.e., not still held by the implementer or failed there), where an
+    invalid "Source:" or "Changeset:" value never stacks, and where the implementer is
+    recognized by the tag <implementer> (default: the tag of the agent itself, so the
+    definition reused under another tag recognizes its own implementing), while the
+    integrator is recognized by the tag of the built-in integrator by convention  */
+const passes = (implementer) => (pred, succ, ctx) => {
+    const held = (tag) => pred.tags.includes(`${tag}:active`) || pred.tags.includes(`${tag}:failed`);
+    const changeset = ctx.flow(pred, "Changeset");
+    const source = ctx.flow(succ, "Source");
+    const stacked = changeset?.type === "branch" && source?.type === "branch" && changeset.name === source.name;
+    const states = ctx.lifecycle.states;
+    if (stacked)
+        return states.indexOf(pred.status) >= states.indexOf("IMPLEMENTED")
+            && !(pred.status === "IMPLEMENTED" && held(implementer ?? ctx.agent.tag));
+    else
+        return pred.status === "INTEGRATED" && !held("ase-agent-integrator");
+};
+/*  agent "ase agent implementer"  */
+export default {
+    kind: "implementer",
+    description: "Drive the \"Implementation\" phase of the \"enterprise\" task lifecycle model: claim " +
+        "every \"PLANNED\" task unassigned or assigned to the implementer, not yet tagged " +
+        "\"ase-agent-implementer\", and with integrated \"After:\" predecessors (or implemented ones, " +
+        "if stacked onto their \"branch:\" changeset by its \"Source:\") into " +
+        "\"IMPLEMENTING\", implement it from its \"Source:\" into its \"Changeset:\" via the " +
+        "\"ase-task-implement\" skill (in a Git worktree where needed), tag it, and put it into " +
+        "\"STALLED\" unless it became \"IMPLEMENTED\" (tagged \"ase-agent-implementer:failed\" " +
+        "if its branch could not be published), or, with \"--mode draft\", only draft the " +
+        "implementation of tasks without a draft yet into their \"draft\" attachment and put " +
+        "them back into \"PLANNED\", logging to stdout and to the \"agent\" " +
+        "attachment of the task",
+    modeDesc: "\"implement\" to implement the task into its changeset, or \"draft\" " +
+        "to just draft its implementation into its \"draft\" attachment",
+    mode: "implement",
+    modes: {
+        /*  implement the task from its source into its changeset, which the skill itself puts
+            into "IMPLEMENTED" on success (else it is stalled), where a "branch:" changeset is
+            implemented in place in the worktree carrying its branch, while the "Source:" of the
+            plan stays in effect, the change set snapshot is attached by the agent itself, based
+            on the fork point of the branch from its source (and hence shows the entire branch,
+            also on a re-run of a declined task), and the work on it is afterwards committed onto
+            it and published  */
+        implement: {
+            title: "Implement planned tasks into their changesets",
+            description: "Claims every PLANNED task unassigned or assigned to the implementer, not yet implemented, " +
+                "and with integrated After: predecessors into IMPLEMENTING. Implements its plan from its " +
+                "Source: into its Changeset: via the ase-task-implement skill (in a Git worktree where " +
+                "needed), commits and publishes a branch: changeset, attaches a snapshot of the change " +
+                "set, and puts it into IMPLEMENTED on success, else into STALLED.",
+            params,
+            type: "phase",
+            lifecycle: "enterprise",
+            workdir: "changeset",
+            state: { incoming: "PLANNED", activity: "IMPLEMENTING", success: "IMPLEMENTED", failure: "STALLED", passed: "IMPLEMENTED" },
+            tag: { name: "ase-agent-implementer" },
+            prompt: {
+                skill: "ase-task-implement",
+                args: "--next DONE{?changeset-type=branch: --changeset worktree}" +
+                    "{?changeset-worktree: --worktree {changeset-worktree}} {id}"
+            },
+            success: { criterion: ["status"] },
+            attach: { changeset: "changeset" },
+            finish: { commit: true },
+            hooks: { passes: passes(), ready }
+        },
+        /*  draft the implementation of the task into its "draft" attachment only (in a temporary
+            worktree of the skill, from the source commit, without uncommitted changes, so the
+            working copy is used as-is and the drafts are parallel-safe), where the skill leaves
+            the task status untouched, so it is put back into "PLANNED" in any case, untagged
+            if drafted (as its draft attachment itself keeps it from being drafted again), and
+            else tagged with a tag separate from the one of the implementing, so a drafted task
+            is still implemented later  */
+        draft: {
+            title: "Draft the implementation of planned tasks",
+            description: "Claims every PLANNED task without an implementation draft yet into IMPLEMENTING. Drafts " +
+                "its implementation via the ase-task-implement skill into its draft attachment only (in a " +
+                "temporary worktree, leaving the working copy untouched), and puts it back into PLANNED in " +
+                "any case, so it can still be implemented later.",
+            params,
+            type: "phase",
+            lifecycle: "enterprise",
+            workdir: "source",
+            state: { incoming: "PLANNED", activity: "IMPLEMENTING", success: "PLANNED", failure: "PLANNED", phase: "IMPLEMENTED", passed: "IMPLEMENTED" },
+            tag: { name: "ase-agent-implementer-draft", success: "none" },
+            attach: { skip: "text/x-diff;draft", expect: "text/x-diff;draft" },
+            prompt: { skill: "ase-task-implement", args: "--next DONE --draft --stateless {id}" },
+            success: { criterion: ["exit", "attachment"] },
+            hooks: { passes: passes("ase-agent-implementer"), ready }
+        }
+    }
+};

package/dst/ase-agent-definition-builtin/integrator.js

@@ -0,0 +1,56 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+/*  integrate the changeset of the task into its target by the Git operation <mode> (described
+    as <how>), where the skill itself puts the task into "INTEGRATED" on success, so the task counts as
+    integrated on the "plan integrated" status of the skill only (else it is deferred), where
+    the agent itself attaches the change set snapshot of the change set which finally landed
+    on the target, and where the tasks are processed serially only, as merges into the same
+    target branch cannot run concurrently  */
+const integrate = (mode, how) => ({
+    title: `Integrate qualified tasks by ${how}`,
+    description: "Claims every QUALIFIED task unassigned or assigned to the integrator, not yet integrated, " +
+        "and with integrated After: predecessors into INTEGRATING, one task at a time. Integrates " +
+        `its Changeset: into its Target: by ${how} via the ase-task-integrate skill, attaches a ` +
+        "snapshot of the landed change set, and puts it into INTEGRATED on success, else into DEFERRED.",
+    type: "phase",
+    lifecycle: "enterprise",
+    serial: true,
+    workdir: "target",
+    state: { incoming: "QUALIFIED", activity: "INTEGRATING", success: "INTEGRATED", failure: "DEFERRED", passed: "INTEGRATED" },
+    tag: { name: "ase-agent-integrator" },
+    prompt: {
+        skill: "ase-task-integrate",
+        args: `--next DONE --mode ${mode}{?changeset-worktree: --worktree {changeset-worktree}} {id}`
+    },
+    success: { criterion: ["exit"], match: ["status:\\W*plan integrated\\b"] },
+    attach: { changeset: "changeset" }
+});
+/*  agent "ase agent integrator"  */
+export default {
+    kind: "integrator",
+    description: "Drive the \"Integration\" phase of the \"enterprise\" task lifecycle model: claim every " +
+        "\"QUALIFIED\" task unassigned or assigned to the integrator (by its name), without tag " +
+        "\"ase-agent-integrator\", and with integrated \"After:\" predecessors into " +
+        "\"INTEGRATING\", integrate its \"Changeset:\" into its \"Target:\" (a \"branch:\" " +
+        "target not checked out yet in a temporary Git worktree) via the headless agent tool and " +
+        "the \"ase-task-integrate\" skill (by a merge, rebase, or squash after \"--mode\"), tag " +
+        "it with \"ase-agent-integrator\", and put it into \"INTEGRATED\" if integrated, or into " +
+        "\"DEFERRED\" otherwise (or \"QUALIFIED\" untagged on interrupt, or left \"INTEGRATED\" " +
+        "with tag \"ase-agent-integrator:failed\" if its integrated target branch could not be " +
+        "published), processing the tasks serially (ignoring \"--parallel\") and logging to " +
+        "stdout and to the \"agent\" attachment of the task",
+    modeDesc: "\"merge\", \"rebase\", or \"squash\" to integrate the changeset " +
+        "into the target by a merge commit, a rebase with fast-forward, or a squash commit",
+    mode: "squash",
+    modes: {
+        /*  create a merge commit  */
+        merge: integrate("merge", "a merge commit"),
+        /*  rebase the changeset onto the target and fast-forward the target  */
+        rebase: integrate("rebase", "a rebase with fast-forward"),
+        /*  combine the changeset into one new commit on the target  */
+        squash: integrate("squash", "a squash commit")
+    }
+};

package/dst/ase-agent-definition-builtin/qualifier.js

@@ -0,0 +1,61 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+/*  review the changeset of the task (a "worktree" one staged, a "branch:" one against its
+    base, an "attachment:" one staged in a temporary Git worktree) and tag the task with the
+    verdict "APPROVE" resp. "REJECT" of the review (or plain without a verdict, e.g. on a
+    failed or skipped review), where the task is put back into "IMPLEMENTED" for a human
+    decision, except where the verdict decides on its resulting status  */
+const review = (verdicts) => ({
+    type: "phase",
+    lifecycle: "enterprise",
+    workdir: "changeset-read",
+    state: {
+        incoming: "IMPLEMENTED", activity: "QUALIFYING", success: "IMPLEMENTED", failure: "IMPLEMENTED",
+        phase: "QUALIFIED", passed: "QUALIFIED", verdict: verdicts
+    },
+    tag: { name: "ase-agent-qualifier" },
+    prompt: { skill: "ase-repo-review", args: "{?changeset-type=branch:--branch {changeset-name}}" },
+    verdict: { label: "REVIEW VERDICT", allow: ["APPROVE", "REJECT"] },
+    success: { criterion: ["exit", "verdict"] }
+});
+/*  agent "ase agent qualifier"  */
+export default {
+    kind: "qualifier",
+    description: "Drive the \"Qualification\" phase of the \"enterprise\" task lifecycle model: " +
+        "claim every \"IMPLEMENTED\" task unassigned or assigned to the qualifier (by its name), without tag " +
+        "\"ase-agent-qualifier\" (i.e., without its verdict yet), and with qualified \"After:\" predecessors into " +
+        "\"QUALIFYING\", review its \"Changeset:\" (a \"worktree\" one staged, a \"branch:\" one " +
+        "against its base, an \"attachment:\" one staged in a temporary Git worktree) via the headless " +
+        "agent tool and the \"ase-repo-review\" skill, tag it with its verdict \"ase-agent-qualifier:approve\" " +
+        "or \"ase-agent-qualifier:reject\" (or plain \"ase-agent-qualifier\" without a verdict), and put it back " +
+        "into \"IMPLEMENTED\" for a human decision (\"--mode judge\"), or into \"QUALIFIED\" resp. \"DECLINED\" by " +
+        "its verdict (\"--mode qualify\", and back into \"IMPLEMENTED\" without a verdict), " +
+        "untagged into \"IMPLEMENTED\" on interrupt, " +
+        "logging to stdout and to the \"agent\" attachment of the task",
+    modeDesc: "\"judge\" to just add the verdict tag, or \"qualify\" to additionally " +
+        "qualify resp. decline the task by its verdict",
+    mode: "judge",
+    modes: {
+        /*  just add the verdict  */
+        judge: {
+            ...review([]),
+            title: "Review implemented tasks and tag their verdict",
+            description: "Claims every IMPLEMENTED task unassigned or assigned to the qualifier, without a verdict " +
+                "yet, and with qualified After: predecessors into QUALIFYING. Reviews its Changeset: via the " +
+                "ase-repo-review skill, tags it with its verdict (approve or reject), and puts it back into " +
+                "IMPLEMENTED for the final decision by a human."
+        },
+        /*  additionally decide on the resulting task status by the verdict  */
+        qualify: {
+            ...review(["APPROVE=QUALIFIED", "REJECT=DECLINED"]),
+            title: "Review implemented tasks and decide by verdict",
+            description: "Claims every IMPLEMENTED task unassigned or assigned to the qualifier, without a verdict " +
+                "yet, and with qualified After: predecessors into QUALIFYING. Reviews its Changeset: via the " +
+                "ase-repo-review skill, tags it with its verdict (approve or reject), and puts it into " +
+                "QUALIFIED resp. DECLINED by its verdict, or back into IMPLEMENTED without any verdict."
+        }
+    }
+};