@rse/ase 0.9.54 → 0.9.56

package/plugin/skills/ase-task-implement/SKILL.md

@@ -75,7 +75,7 @@ Procedure
     </if>
 
     1.  Set <worktree-name><ase-task-id/></worktree-name>. The worktree
-        is *never* named by an own option value: it always carries the
+        is *never* named by its own option value: it always carries the
         unique *task id*, so the worktree directory and its branch stay
         unambiguously tied to the very task plan implemented in them.
         The task id is a plain identifier by construction, hence it is
@@ -89,7 +89,7 @@ Procedure
         `git rev-parse --show-toplevel`
 
         <if condition="this command fails">
-        The current directory is no Git repository, so no worktree can be
+        The current directory is not a Git repository, so no worktree can be
         created. Only output the following <template/> and then
         immediately *STOP* processing the entire current skill, leaving
         the working copy *untouched*:
@@ -189,13 +189,46 @@ Procedure
         way.
         </if>
 
-    2.  Only output the following <template/>:
+    2.  Update the frontmatter of <task-content/> as follows, *creating*
+        each of the `Properties:`, `Status:`, and `Modified:` keys the
+        plan does not carry yet at its position in the key order of the
+        plan <format/>:
+
+        -   *Add* the value `implemented` to the `Properties:` key if it
+            is still absent, keeping all already present values.
+
+        -   *Add* the value `verified` to the `Properties:` key as well,
+            but *only* if the verification phase was actually performed
+            and succeeded -- hence *never* for a plan whose
+            `##  VERIFICATION` section is deliberately omitted.
+
+        -   Set the `Status:` key to `COMPLETED`, but *only* if the
+            change set was applied *completely* and *successfully* --
+            this traverses the `approve`, `start`, and `complete`
+            transitions of the state machine of the plan <format/> in one
+            go, starting from the `DRAFTED` state which a freshly authored
+            plan carries. Otherwise leave the `Status:` key *untouched*,
+            as an incomplete run transitioned nowhere.
+
+        -   Refresh the `Modified:` key with the current time in
+            ISO-style format, determined by calling the
+            `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
+            MCP server.
+
+        Apart from the frontmatter keys above, the plan body *MUST* stay
+        *exactly* as loaded.
+
+        Finally call the `ase_task_save(id: "<ase-task-id/>", text:
+        "<task-content/>")` tool of the `ase` MCP server to persist the
+        updated task plan. Do not output anything in this sub-step.
+
+    3.  Only output the following <template/>:
 
         <template>
         ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented**
         </template>
 
-    3.  <if condition="<worktree-dir/> is not empty">
+    4.  <if condition="<worktree-dir/> is not empty">
         Give the closing hint by expanding the following (which,
         depending on the configured <ase-guidance-level/>, may expand
         into nothing and hence emit no output at all):

package/plugin/skills/ase-task-implement/help.md

@@ -16,14 +16,18 @@
 The `ase-task-implement` skill performs the *final implementation* of
 a task plan by modifying the corresponding *artifacts* with a complete
 *change set*. The plan is loaded and any optional `IMPLEMENTATION DRAFT`
-section produced by `ase-task-preflight` is used as a hint - the plain
-plan content always overrules the draft.
-
-The *kind of change* stated by the plan's `☯   Kind:` header line
+section produced by `ase-task-preflight` is used as a hint -- the plain
+plan content always overrules the draft. Afterwards the plan's
+`Properties:` frontmatter key gains the value `implemented` (plus
+`verified`, if the verification phase actually ran and succeeded), and
+its `Status:` key becomes `COMPLETED` if the change set was applied
+completely and successfully.
+
+The *kind of change* stated by the plan's `Kind:` frontmatter key
 (`CRAFTING`, `REFACTORING`, or `RESOLVING`) selects which
 *operation-specific tenet set* of the **ASE Tenets** is internalized
 before any artifact is touched, in addition to the always applying
-**GENERIC TENETS**. If a plan carries no such line, the kind is
+**GENERIC TENETS**. If a plan carries no such key, the kind is
 *inferred* from the plan content, defaulting to `CRAFTING`.
 
 If the task plan deliberately *omits* the `##  VERIFICATION` section

package/plugin/skills/ase-task-list/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ase-task-list
-argument-hint: "[--help|-h] [--verbose|-v]"
+argument-hint: "[--help|-h] [--verbose|-v] [--include|-i=<state>[,...]] [--exclude|-e=<state>[,...]]"
 description: >
     List all available task ids.
     Use when user wants to see all tasks.
@@ -19,7 +19,7 @@ List Task Plans
 
 <expand name="getopt"
     arg1="ase-task-list"
-    arg2="--verbose|-v">
+    arg2="--verbose|-v --include|-i=none --exclude|-e=COMPLETED,CANCELLED">
     $ARGUMENTS
 </expand>
 
@@ -30,13 +30,49 @@ List Task Plans
 Procedure
 ---------
 
-1.  Call the `ase_task_list(verbose: <getopt-option-verbose/>)` tool from
+1.  Determine the *effective state set* <states/>, i.e., the lifecycle
+    states a task plan has to be in to be listed at all. For this, parse
+    <getopt-option-include/> and <getopt-option-exclude/> as
+    comma-separated token lists, silently dropping the `none` sentinel
+    and any empty token. If a token <token/> is *not* one of the eight
+    `Status:` values `DRAFTED`, `REJECTED`, `APPROVED`, `DEFERRED`,
+    `STARTED`, `BLOCKED`, `COMPLETED`, or `CANCELLED`, only output the
+    following <template/> and then *STOP* processing the entire current
+    skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-task-list**, ▶ ERROR: invalid state: **<token/>**
+    </template>
+
+    Otherwise set <states/> to *all* eight states if both lists are
+    empty, to the *include* list if only it is non-empty, to all eight
+    *minus* the *exclude* list if only it is non-empty, and to the
+    *include* list *minus* the *exclude* list if both are non-empty. If
+    the resulting <states/> is *empty*, only output the following
+    <template/> and then *STOP* processing the entire current skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-task-list**, ▶ ERROR: options `--include` and `--exclude` cancel out to an empty state set
+    </template>
+
+    Directly *after* this error <template/>, and *before* stopping, give
+    the corrective hint by expanding the following (which, depending on
+    the configured <ase-guidance-level/>, may expand into nothing and
+    hence emit no output at all):
+
+    <ase-tpl-hint level="minimal">
+    The `--exclude` default `COMPLETED,CANCELLED` still applies -- add `--exclude none` to reach states like `COMPLETED` via `--include`.
+    </ase-tpl-hint>
+
+2.  Call the `ase_task_list(verbose: <getopt-option-verbose/>)` tool from
     the `ase` MCP server. The result is a structured object with a
-    `tasks` array where each entry has an `id` field, and -- if
-    <getopt-option-verbose/> is `true` -- additionally an `mtime` field
-    (formatted as `YYYY-MM-DD HH:MM`).
+    `tasks` array where each entry has an `id` and a `status` field, and
+    -- if <getopt-option-verbose/> is `true` -- additionally an `mtime`
+    field (formatted as `YYYY-MM-DD HH:MM`). *Drop* from the `tasks`
+    array every entry whose `status` is *not* contained in <states/>. Do
+    not output anything.
 
-2.  If the `tasks` array is empty, output the following <template/>:
+3.  If the `tasks` array is empty, output the following <template/>:
 
     <template>
     ⧉ **ASE**: ◉ tasks: *(none)*
@@ -45,16 +81,16 @@ Procedure
     Else, dispatch on <getopt-option-verbose/>:
 
     -   If <getopt-option-verbose/> is `true`, output the list of tasks
-        with the following <template/>, where each <id/> and <mtime/>
-        correspond to an entry in the task list:
+        with the following <template/>, where each <id/>, <status/>, and
+        <mtime/> correspond to an entry in the task list:
 
         <template>
         ⧉ **ASE**: ◉ tasks:
 
-        | *Task Id* | *Last Modified*    |
-        |-----------|--------------------|
-        | **<id/>** | `<mtime/>`         |
-        | [...]     | [...]              |
+        | *Task Id* | *Status*    | *Last Modified*    |
+        |-----------|-------------|--------------------|
+        | **<id/>** | `<status/>` | `<mtime/>`         |
+        | [...]     | [...]       | [...]              |
 
         </template>
 
@@ -72,7 +108,7 @@ Procedure
 
         </template>
 
-3.  Finally, give the closing hints by expanding the following (which,
+4.  Finally, give the closing hints by expanding the following (which,
     depending on the configured <ase-guidance-level/>, may each expand
     into nothing and hence emit no output at all):
 
@@ -81,6 +117,11 @@ Procedure
     Use `/ase-task-id <id>` to switch to one of the listed tasks and `/ase-task-view` to inspect its plan.
     </ase-tpl-hint>
     </if>
+    <elseif condition="entries were dropped by the state filtering of step 2">
+    <ase-tpl-hint level="normal">
+    All task plans were filtered out by the effective state set -- use `/ase-task-list --exclude none` to list them regardless of their status.
+    </ase-tpl-hint>
+    </elseif>
     <else>
     <ase-tpl-hint level="normal">
     No task plan exists yet -- use `/ase-task-edit` to create one through a conversational loop.
@@ -89,7 +130,11 @@ Procedure
 
     <if condition="<getopt-option-verbose/> is not equal `true`">
     <ase-tpl-hint level="verbose">
-    Use `/ase-task-list --verbose` to additionally show the last-modified timestamp of each task plan.
+    Use `/ase-task-list --verbose` to additionally show the status and the last-modified timestamp of each task plan.
     </ase-tpl-hint>
     </if>
 
+    <ase-tpl-hint level="verbose">
+    Use `/ase-task-list --include`/`--exclude` to narrow the listing to certain lifecycle states, e.g. `--include STARTED,BLOCKED`.
+    </ase-tpl-hint>
+

package/plugin/skills/ase-task-list/help.md

@@ -8,35 +8,78 @@
 `ase-task-list`
     [`--help`|`-h`]
     [`--verbose`|`-v`]
+    [`--include`|`-i`=*state*[`,`...]]
+    [`--exclude`|`-e`=*state*[`,`...]]
 
 ##  DESCRIPTION
 
 The `ase-task-list` skill lists all available *task ids* in the
 current project by calling the `ase_task_list` MCP tool. In the
 default mode, only the task ids are rendered as a single-column
-Markdown table. In verbose mode, the last-modified timestamp of
-each task plan is rendered as an additional column.
+Markdown table. In verbose mode, the lifecycle status and the
+last-modified timestamp of each task plan are rendered as additional
+columns.
+
+The listing is restricted to an *effective state set*, derived from the
+`Status:` frontmatter key of each task plan (which defaults to `DRAFTED`
+for a plan carrying no such key): with `--include` only, exactly the
+listed states are shown; with `--exclude` only, all states except the
+listed ones; with both, the included ones minus the excluded ones. An
+unknown state, or a combination which cancels out to an empty set,
+aborts the skill with an error. By default,
+`--exclude COMPLETED,CANCELLED` is in effect, so finished and
+abandoned task plans stay out of the way. The eight states are:
+
+```text
+DRAFTED   APPROVED  STARTED  COMPLETED
+REJECTED  DEFERRED  BLOCKED  CANCELLED
+```
 
 ##  OPTIONS
 
 `--verbose`|`-v`:
-    Render an additional `Last Modified` column with the
-    `YYYY-MM-DD HH:MM` timestamp of each task plan.
+    Render an additional `Status` column with the lifecycle state and an
+    additional `Last Modified` column with the `YYYY-MM-DD HH:MM`
+    timestamp of each task plan.
+
+`--include`|`-i`=*state*[`,`...]:
+    Restrict the listed task plans to the given comma-separated list of
+    lifecycle states (e.g. `STARTED,BLOCKED`). Without this option, all
+    eight states are listed. The `none` sentinel selects no state at all.
+
+`--exclude`|`-e`=*state*[`,`...]:
+    Remove the given comma-separated list of lifecycle states from the
+    listed task plans. Applied *after* `--include`, so
+    `-i DRAFTED,STARTED -e STARTED` lists `DRAFTED` only. Defaults to
+    `COMPLETED,CANCELLED`; pass `--exclude none` to suppress the
+    default and list task plans in every state.
 
 ##  EXAMPLES
 
-List all task ids:
+List all unfinished task ids:
 
 ```text
 ❯ /ase-task-list
 ```
 
-List all task ids together with their last-modified timestamps:
+List all task ids together with their status and last-modified timestamps:
 
 ```text
 ❯ /ase-task-list --verbose
 ```
 
+List the task ids of every task plan, including the finished ones:
+
+```text
+❯ /ase-task-list --exclude none
+```
+
+List only the task ids of the task plans currently under work:
+
+```text
+❯ /ase-task-list --include STARTED,BLOCKED
+```
+
 ##  SEE ALSO
 
 [`ase-task-id`](../ase-task-id/help.md), [`ase-task-view`](../ase-task-view/help.md), [`ase-task-edit`](../ase-task-edit/help.md),

package/plugin/skills/ase-task-preflight/SKILL.md

@@ -78,25 +78,37 @@ Procedure
         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
 
-        ```text
+        <fence/>text
         <unified-diff/>
-        ```
+        <fence/>
 
         </template>
 
-    3.  <if condition="<task-content/> contains '⚙   Modified:'">
-        Update <timestamp-modified/> with the current time in
+    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 use the `text` field of its response. Update
-        the `⚙   Modified: ...` line of <task-content/> with the new
-        `⚙   Modified: <timestamp-modified/>`.
+        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.
-        </if>
+
+        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

package/plugin/skills/ase-task-preflight/help.md

@@ -16,14 +16,15 @@ The `ase-task-preflight` skill performs a *preflight* (dry-run,
 test-drive) of the *implementation* of a task plan by creating a
 draft for a corresponding, complete *artifact change set* in
 *unified diff* format. The draft is appended to the task plan as
-an `IMPLEMENTATION DRAFT` section (replacing any previous draft).
+an `IMPLEMENTATION DRAFT` section (replacing any previous draft) and
+the plan's `Properties:` frontmatter key gains the value `preflighted`.
 No source files are modified.
 
-The *kind of change* stated by the plan's `☯   Kind:` header line
+The *kind of change* stated by the plan's `Kind:` frontmatter key
 (`CRAFTING`, `REFACTORING`, or `RESOLVING`) selects which
 *operation-specific tenet set* of the **ASE Tenets** is internalized
 before the draft is produced, in addition to the always applying
-**GENERIC TENETS**. If a plan carries no such line, the kind is
+**GENERIC TENETS**. If a plan carries no such key, the kind is
 *inferred* from the plan content, defaulting to `CRAFTING`.
 
 After the preflight, the user is asked whether to stop, hand

package/plugin/skills/ase-task-reboot/SKILL.md

@@ -21,7 +21,7 @@ Reboot a Task Plan
 
 <expand name="getopt"
     arg1="ase-task-reboot"
-    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)...">
+    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)... --int-reuse-task">
     $ARGUMENTS
 </expand>
 
@@ -46,51 +46,13 @@ Procedure
 
     2.  React on task id:
 
-        1.  <if condition="
-                <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-            ">
-            Set <ase-task-id><instruction/></ase-task-id> (set task
-            id to instruction) and <instruction></instruction> (set
-            instruction empty), call the `ase_task_id(id: "<ase-task-id/>",
-            session: "<ase-session-id/>")` tool from the `ase` MCP
-            server to switch the task, and then only output the
-            following <template/>:
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
-            </template>
-            </if>
-
-        2.  <elseif condition="<instruction/> is NOT empty">
-            The argument is neither empty nor a valid task id. As this
-            skill only accepts an optional `[<id>]` argument and *never*
-            a free-text instruction, only output the following <template/>
-            and then immediately *STOP* processing the entire current skill:
-
-            <template>
-            ⧉ **ASE**: ☻ skill: **ase-task-reboot**, ▶ ERROR: expected single `[<id>]` argument
-            </template>
-            </elseif>
+        <expand name="task-react-id" arg1="ase-task-reboot"></expand>
 
 2.  **Determine Operation:**
 
-    1.  Call the `ase_task_load(id: "<ase-task-id/>")` tool of the `ase` MCP
-        server to load the current task plan content and set <text/> to
-        the `text` output field of the `ase_task_load` tool call.
-
-        -   If <text/> starts with `ERROR:` or `WARNING:`:
-            Set <task-content></task-content> (set task content to empty).
-            Set <words/> to "0".
-
-        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
-            Set <task-content><text/></task-content> (set task content to text).
-            Calculate the number of words <words/> of <task-content/>.
+    1.  Determine the current task plan content:
 
-        Only output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan loaded**
-        </template>
+        <expand name="task-load-content"></expand>
 
     2.  <if condition="<task-content/> is empty">
         Complain and tell the user to use the `ase-code-resolve`,
@@ -102,33 +64,28 @@ Procedure
 3.  **Reboot Task Plan:**
 
     1.  Start with <instruction></instruction> (set instruction to empty).
+        Do not output anything.
 
-        The loaded <task-content/> is the *rendering-prepared* variant of
-        the plan, so its bullet markers can be rendered as `◯` instead
-        of the authored `-`. Set <marker>◯</marker> if the bullet points
-        of <task-content/> start with `◯`, and set <marker>-</marker>
-        otherwise. Do not output anything.
-
-    2.  <if condition="<task-content/> contains neither '<marker/>   **WHAT**:' nor '<marker/>   **WHY**:'">
+    2.  <if condition="<task-content/> contains neither '-   **WHAT**:' nor '-   **WHY**:'">
         Set <instruction><task-content/></instruction> (set instruction to task content).
         </if>
 
-    3.  <if condition="<task-content/> contains '<marker/>   **WHAT**: <text/>'">
+    3.  <if condition="<task-content/> contains '-   **WHAT**: <text/>'">
         Set <instruction><text/></instruction> (set instruction to extracted text).
         </if>
 
-    4.  <if condition="<task-content/> contains '<marker/>   **WHY**: <text/>' and <instruction/> is empty">
+    4.  <if condition="<task-content/> contains '-   **WHY**: <text/>' and <instruction/> is empty">
         Set <instruction><text/></instruction> (set instruction to extracted text).
         </if>
 
-    5.  <if condition="<task-content/> contains '<marker/>   **WHY**: <text/>' and <instruction/> is NOT empty">
+    5.  <if condition="<task-content/> contains '-   **WHY**: <text/>' and <instruction/> is NOT empty">
         Set <instruction><instruction/>, BECAUSE <text/></instruction>
         (append extracted text to instruction).
         </if>
 
-    6.  <if condition="<task-content/> contains '⎈   Created:  <text/>'">
+    6.  <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
         Set <timestamp-created><text/></timestamp-created> (set
-        timestamp-created to extracted text)
+        timestamp-created to extracted text).
         </if>
 
     7.  <if condition="<instruction/> is empty or contains only whitespace">
@@ -148,19 +105,19 @@ Procedure
         </if>
         </if>
 
-    8.  Create a new plan from scratch and store the result as
+    8.  Only output the following <template/> and continue processing:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+        </template>
+
+    9.  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/>.
 
-    9.  <expand name="task-save-content" arg1="plan rebooted"></expand>
-
-    10. Only output the following <template/> and continue processing:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
-        </template>
+    10. <expand name="task-save-content" arg1="plan rebooted"></expand>
 
 4.  **Decide Next Step:**
 

package/plugin/skills/ase-task-reboot/help.md

@@ -15,7 +15,7 @@
 The `ase-task-reboot` skill re-creates an existing task plan *from
 scratch* by extracting the original `**WHAT**` and `**WHY**` sections
 (if present) from the current plan, using them as the new instruction,
-preserving the original creation timestamp, and writing a fresh plan
+preserving the original creation timestamp, and writing fresh plan
 content via `ase_task_save`.
 
 After the reboot, the user is asked whether to stop or hand off to

package/plugin/skills/ase-task-view/SKILL.md

@@ -54,8 +54,10 @@ Procedure
 
 2.  **Perform Operation**:
 
-    1.  Call the `ase_task_load(id: "<id/>")` tool of the `ase` MCP
-        server to load the task plan content and set <text/> to the
+    1.  Call the `ase_task_load(id: "<id/>", variant: "render")` tool
+        of the `ase` MCP server to load the task plan content in its
+        *rendering-prepared* form -- this skill is *display-only* and
+        hence never persists the plan again -- and set <text/> to the
         `text` output field of this `ase_task_load` tool call. Do not
         output anything related to this MCP tool call.
 
@@ -78,6 +80,27 @@ Procedure
 
     2.  <if condition="<task-content/> is not empty">
         Treat <task-content/> as *verbatim* Markdown.
+
+        For the *rendering only*, drop the leading *frontmatter* block --
+        both `---` delimiters and all of their keys -- and instead place
+        the following column-aligned glyph lines *before* the
+        `#   TASK: <title/>` heading, separated from it by an empty line,
+        omitting the line of every key absent from the frontmatter. The
+        glyph lines *MUST* stay *above* the heading, exactly where the
+        frontmatter block sits in the plan file, and *MUST NOT* be moved
+        below it. This keeps the `---` delimiters from rendering as a
+        horizontal rule plus a *setext heading*. This rewrite is
+        *display-only* and *MUST NOT* change <task-content/> itself:
+
+        <format>
+        ◉   **Id:**         <task-id/>
+        ⎈   **Created:**    <timestamp-created/>
+        ⚙   **Modified:**   <timestamp-modified/>
+        ◐   **Status:**     <task-status/>
+        ⚑   **Properties:** <task-properties/>
+        ☯   **Kind:**       <task-kind/>
+        </format>
+
         *Render plan*: Only output the following <template/>. If
         <getopt-option-full/> is *not* `true`, <task-content/> is longer than
         90 lines, and a `##  IMPLEMENTATION DRAFT` section (from the
@@ -87,9 +110,9 @@ Procedure
         Use the following <template/>:
 
         <template>
-        <ase-tpl-head title="TASK"/>
+        <ase-tpl-head title="TASK" subtitle="<task-id/>"/>
         <task-content/>
-        <ase-tpl-foot title="TASK"/>
+        <ase-tpl-foot title="TASK" subtitle="<task-id/>"/>
         </template>
         </if>
 

package/dst/ase-guidance.js

@@ -1,89 +0,0 @@
-/*
-**  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 { isScalar } from "yaml";
-import { z } from "zod";
-import { Config, configSchema, parseScope, agentClassification } from "./ase-config.js";
-/*  reusable functionality: ASE agent guidance level get/set  */
-export class Guidance {
-    /*  allowed guidance level values  */
-    static levels = agentClassification.guidance;
-    /*  get the effective guidance level for an optional session;
-        returns the default "normal" if nothing is configured  */
-    static get(log, session) {
-        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
-        const cfg = new Config("config", configSchema, log, scope);
-        cfg.read();
-        const val = cfg.get("agent.guidance");
-        if (val === undefined)
-            return "normal";
-        const level = String(isScalar(val) ? val.value : val);
-        return Guidance.levels.find((l) => l === level) ?? "normal";
-    }
-    /*  set the guidance level on the strongest scope of an optional session  */
-    static set(log, level, session) {
-        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
-        const cfg = new Config("config", configSchema, log, scope);
-        cfg.lock(() => {
-            cfg.read();
-            cfg.set("agent.guidance", level);
-            cfg.write();
-        });
-    }
-}
-/*  MCP registration entry point for guidance tools  */
-export default class GuidanceMCP {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    register(mcp) {
-        mcp.registerTool("ase_guidance", {
-            title: "ASE guidance level get/set",
-            description: "Get or set the active ASE agent guidance `level`. " +
-                "If `level` is provided, it sets the guidance level, " +
-                "otherwise it returns the current guidance `level`. " +
-                "If `session` is provided, the operation is scoped to that session, " +
-                "otherwise it operates on the strongest/closest scope (user/project cascade). " +
-                "The guidance level controls the amount of unsolicited help hints -- " +
-                "pointers to the available ASE skills, their options, and the recommended " +
-                "next operations -- the agent emits. " +
-                "Allowed levels: \"none\" (no help hints at all), " +
-                "\"minimal\" (the single most essential help hint only), " +
-                "\"normal\" (the essential help hints only), " +
-                "\"verbose\" (all available help hints).",
-            inputSchema: {
-                level: z.enum(Guidance.levels).optional()
-                    .describe("guidance level to set; if omitted, the current guidance level is returned"),
-                session: z.string().regex(/^[A-Za-z0-9._-]+$/).optional()
-                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-'); " +
-                    "if omitted, the operation is not scoped to a specific session")
-            }
-        }, async (args) => {
-            try {
-                if (args.level !== undefined) {
-                    Guidance.set(this.log, args.level, args.session);
-                    const where = args.session !== undefined ?
-                        ` for session "${args.session}"` : "";
-                    const msg = `OK: set agent.guidance to "${args.level}"${where}`;
-                    return {
-                        content: [{ type: "text", text: msg }]
-                    };
-                }
-                const text = Guidance.get(this.log, args.session);
-                return {
-                    content: [{ type: "text", text }]
-                };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `ERROR: ${message}` }]
-                };
-            }
-        });
-    }
-}