@rse/ase 2.0.1 → 2.0.3

package/plugin/skills/ase-repo-changelog/SKILL.md

@@ -58,10 +58,9 @@ related changes:
 The <artifact-kind/> is one or more of the following *artifact* tags,
 classifying which kind of artifact the change primarily touches. If
 multiple artifact kinds apply, comma-separate them
-(e.g. `[arch, code]`):
+(e.g. `[code, docs]`):
 
     -   `spec`:  requirement/specification artifacts
-    -   `arch`:  architecture/design artifacts
     -   `code`:  source code artifacts
     -   `docs`:  documentation artifacts
     -   `infr`:  infrastructure/build/tooling artifacts
@@ -114,14 +113,14 @@ Processing
     level-2 section (next patch version, current date) *above* it, which
     then becomes the *first* (most recent) section all subsequent steps
     operate on - the already released section *MUST* *NOT* be modified.
-    If this command produces *no* output, the
-    first section is still in-progress/untagged, so use the `N.M.K` from
-    the *second* level-2 header as the baseline tag instead. If *no*
+    If this command produces *no* output, the first section is still
+    in-progress/untagged, so use the `N.M.K` from the *second* level-2
+    header as the baseline tag instead. Then check all Git commits
+    between `HEAD` and this baseline tag with the command
+    `git log N.M.K..HEAD --numstat --pretty=format:'%h: %s'`. If *no*
     second level-2 header exists (very first, still untagged release),
     skip the baseline tag and check *all* Git commits with the command
-    `git log HEAD --numstat --pretty=format:'%h: %s'` instead. Then
-    check all Git commits between `HEAD` and this baseline tag with the
-    command `git log N.M.K..HEAD --numstat --pretty=format:'%h: %s'`.
+    `git log HEAD --numstat --pretty=format:'%h: %s'` instead.
 
     For finding the corresponding staged Git *changes* in the Git
     *index*, use the command `git diff --cached --numstat`, but silently
@@ -152,7 +151,7 @@ Processing
     tag(s) from the paths of the changed files. To classify a changed
     file to its artifact class, call the `ase_artifact_list(kind: [
     ... ])` tool of the `ase` MCP server *once*, passing the `kind`
-    tokens (`spec`, `arch`, `code`, `docs`, `infr`, `othr`), and read
+    tokens (`spec`, `code`, `docs`, `infr`, `othr`), and read
     the returned `artifacts` array of `{ kind, files }` objects to match
     each changed file to its kind. Use the matched lower-cased kind
     directly as its <artifact-kind/> tag, and comma-separate multiple

package/plugin/skills/ase-repo-changelog/help.md

@@ -18,8 +18,8 @@ changes in the Git *index*.
 Each entry is formatted as `<change-type> [<artifact-kind>]: <summary>`
 where *change-type* is one of `FEATURE`, `IMPROVEMENT`, `BUGFIX`,
 `UPDATE`, `CLEANUP`, or `REFACTOR`, and *artifact-kind* is one or more
-comma-separated *artifact class* tags out of `spec`, `arch`, `code`,
-`docs`, `infr`, or `othr`. Entries are grouped and sorted by this
+comma-separated *artifact class* tags out of `spec`, `code`, `docs`,
+`infr`, or `othr`. Entries are grouped and sorted by this
 prefix. The date in the section header is also updated to the current
 date.
 

package/plugin/skills/ase-repo-review/SKILL.md

@@ -224,11 +224,12 @@ Procedure
 
 2.  <step id="STEP 2: Review Investigation">
 
-    <if condition="<ase-project-boxing/> is equal `black`">
+    <if condition="<ase-project-boxing/> is equal `black` and <getopt-option-severity/> is equal `AUTO`">
 
     The project source artifacts are classified as a *black box*, so
     the user does *not* want the changes scrutinized or their
-    findings surfaced. *Skip* the entire review investigation: do
+    findings surfaced (an *explicitly* given severity floor lifts this
+    skip). *Skip* the entire review investigation: do
     *not* invoke the `Agent` tool and do *not* read any change, set
     <findings/> to the *empty* list, set <hidden/> to `0`, set
     <verdict/> to `SKIPPED (boxing: black)`, set <summary/> to a
@@ -288,7 +289,8 @@ Procedure
     <else>
     Set <floor><getopt-option-severity/></floor> and
     <floor-origin>--severity <getopt-option-severity/></floor-origin>:
-    an *explicitly* given severity floor always *wins* over the boxing.
+    an *explicitly* given severity floor always *wins* over the boxing,
+    both over the `grey` floor and over the `black` skip.
     </else>
 
     Then *apply the effective severity floor* <floor/>: *Keep* a finding

package/plugin/skills/ase-repo-review/help.md

@@ -75,7 +75,9 @@ before it is committed or merged.
     threshold are suppressed, ordered `LOW` < `MEDIUM` < `HIGH`. The
     default `AUTO` means `MEDIUM` for a project with `grey` boxing and
     `LOW` (keep all findings) otherwise; an explicitly given floor always
-    wins over the boxing. `ACCEPTED` findings are never suppressed, and
+    wins over the boxing, i.e. it also reviews a project with `black`
+    boxing and, e.g. with `LOW`, shows all findings of a project with
+    `grey` boxing. `ACCEPTED` findings are never suppressed, and
     the number of suppressed findings is always reported. Surviving
     findings are rendered in *descending severity* order `HIGH`,
     `MEDIUM`, `LOW`, `ACCEPTED`. The floor only affects the rendered

package/plugin/skills/ase-spec-edit/SKILL.md

@@ -47,7 +47,8 @@ and *MUST* *NOT* call `ase_task_save(...)`. Instead, it applies the
 requested edit *in place*, so the *implementing* state *requires* `Edit`
 and `Write` to modify the affected artifacts. Every modification *MUST*
 stay restricted to the `SPEC` artifacts the edit actually demands -- the
-kinds `CODE`, `DOCS`, `TASK`, `INFR`, and `OTHR` are *never* touched.
+kinds `CODE`, `DOCS`, `TASK`, `INFR`, and `OTHR` are *never* touched,
+except for an entry in an already existing `CHANGELOG.md` file.
 
 <define name="todo-box">
 

package/plugin/skills/ase-spec-edit/help.md

@@ -44,7 +44,8 @@ approach selection close with an `EDIT TODO` box showing the established
 
 The change set stays strictly restricted to the `SPEC` artifacts -- the
 artifact kinds `CODE`, `DOCS`, `TASK`, `INFR`, and `OTHR` are never
-touched. Every generated artifact carries the current `Created:` and
+touched, except for an entry in an already existing `CHANGELOG.md`
+file. Every generated artifact carries the current `Created:` and
 `Modified:` timestamps, and every changed artifact gets its `Modified:`
 timestamp refreshed.
 

package/plugin/skills/ase-sync-reconcile/help.md

@@ -70,13 +70,13 @@ a unified diff instead.
     as nothing is written to disk.
 
 -   `--target`|`-t` *target*[,...]:
-    The comma-separated list of artifact kinds to update. Required (the
-    skill errors out on an empty target).
+    The comma-separated list of artifact kinds to update (default:
+    `CODE,DOCS,INFR,OTHR`). An empty target lets the skill error out.
 
 -   `--source`|`-s` *source*[,...]:
     The comma-separated list of artifact kinds to update *from*. The
-    special value `auto` resolves to all recognized kinds except those
-    in *target*.
+    special value `auto` (the default) resolves to all recognized kinds
+    except those in *target*.
 
 ##  ARGUMENTS
 

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

@@ -142,7 +142,8 @@ Procedure
 
     2.  *Identify the parts* according to the task id scheme of the
         project: for *every* part in <parts/>, in their derived order,
-        call the `ase_task_newid(title: "<scope/>", proposal:
+        remember its <part-id/> as its <part-proposal/> and call the
+        `ase_task_newid(title: "<scope/>", proposal:
         "<part-id/>", taken: [ <previous/> ])` tool of the `ase` MCP
         server, where <previous/> lists the already re-identified
         <part-id/> of all preceding parts (as the tool reserves ids for
@@ -175,8 +176,9 @@ Procedure
         Call the `ase_task_list(verbose: false)` tool of the `ase` MCP
         server and set <existing/> to the `id` fields of the returned
         `tasks` array. Do not output anything related to this MCP tool
-        call. Set <collisions/> to all <part-id/> of <parts/> which are
-        already present in <existing/>.
+        call. Set <collisions/> to all <part-proposal/> of <parts/> which
+        are already present in <existing/> (as each <part-id/> itself was
+        re-identified to a free id in step 3.2).
 
         <if condition="<collisions/> is not empty AND <getopt-option-force/> is not equal `true`">
         Only output the following <template/> -- with <collisions/>
@@ -200,8 +202,9 @@ Procedure
         </if>
 
         <if condition="<collisions/> is not empty AND <getopt-option-force/> is equal `true`">
-        The colliding sub-task plans are *overwritten* in sub-step 4.3
-        below. Do not output anything.
+        Set the <part-id/> of every colliding part back to its
+        <part-proposal/>, so the colliding sub-task plans are
+        *overwritten* in sub-step 4.3 below. Do not output anything.
         </if>
 
     3.  *Compose and persist one sub-task plan per part*:
@@ -263,7 +266,8 @@ Procedure
             </elseif>
 
         2.  Call the `ase_task_save(id: "<part-id/>", text:
-            "<part-content/>", create: true)` tool of the `ase` MCP server to persist
+            "<part-content/>", create: true)` tool of the `ase` MCP server -- for
+            a part of <collisions/> *without* the `create` argument -- to persist
             the sub-task plan -- this MCP tool call is the *only*
             permitted way to persist it, *NEVER* write the plan file
             via `Write`/`Edit` or by executing a shell command. If this

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

@@ -152,7 +152,7 @@ in state `[-]` (cancelled) or `[>]` (deferred) are never questioned.
 ##  ARGUMENTS
 
 -   *id*:
-    Grill the task with the unique identifier *id* (default: `default`).
+    Grill the task with the unique identifier *id* (default: the current task).
     The skill accepts *only* an optional *id* argument and never a
     free-text instruction.
 

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

@@ -409,6 +409,32 @@ Procedure
         here. Do not output anything.
         </if>
 
+        Set <decisions></decisions> (empty) and
+        <open-points></open-points> (empty). They collect, one entry
+        each, the decisions you take on your own while implementing and
+        whatever ends up waiting for the *user*.
+
+        The implementation is *complete or it is not done*: you *MUST*
+        *NEVER* conclude this step while any point of the task plan is
+        still unimplemented -- not because the change set already grew
+        large, not because the remaining points look secondary or
+        cosmetic, and not because an open question stands in the way.
+        Work through *every* point of the plan within this single run.
+
+        Open questions therefore *MUST* *NOT* end the run: whenever the
+        plan leaves a detail undecided or admits several defensible
+        alternatives, *decide it yourself* -- picking what best fits the
+        surrounding artifacts and the internalized tenets -- and append
+        the decision plus a half-sentence rationale to <decisions/>,
+        instead of asking the user and stopping. Only a *genuine
+        blocker*, which no defensible assumption can bridge (a missing
+        credential, an inaccessible external system), may leave a point
+        unimplemented; append such a point to <open-points/> instead,
+        naming what remains open and why. Append to <open-points/> as
+        well whatever else now waits for the user once this run ends --
+        follow-ups you deliberately left out of scope, each with its
+        reason, and results which genuinely need their review.
+
         You *MUST* *skip* every bullet-point of <task-content/> in
         checkbox state `[-]` (cancelled) or `[>]` (deferred): neither
         realize its <text/> in the change set nor perform its check, and
@@ -594,7 +620,38 @@ Procedure
         ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇢ changeset: **<task-changeset/>**, ▶ status: **plan implemented**
         </template>
 
-    7.  Give the closing hint by expanding the following (which,
+    7.  Close the implementation with the boxed summary of what this run
+        left open and what it decided on its own. Both boxes are written
+        in the conversation language and the active persona style, list
+        *one entry per line*, and are *omitted entirely* when they carry
+        no content -- a run which implemented every point and took no
+        decision of its own outputs no box at all.
+
+        <if condition="<open-points/> is not empty">
+        Output everything which now waits for the *user* with the
+        following <template/>:
+
+        <template>
+        <ase-tpl-boxed title="OPEN POINTS">
+        ○   <open-point/>
+        </ase-tpl-boxed>
+        </template>
+        </if>
+
+        <if condition="<decisions/> is not empty">
+        The run decided open questions *on the user's behalf*, so they
+        *MUST* be able to revisit or overrule each of them. Output the
+        collected decisions -- each naming the chosen option and its
+        rationale -- directly below, with the following <template/>:
+
+        <template>
+        <ase-tpl-boxed title="DECISIONS">
+        ○   <decision/> -- <rationale/>
+        </ase-tpl-boxed>
+        </template>
+        </if>
+
+    8.  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

@@ -102,6 +102,22 @@ the entire verification phase is strictly skipped: no build, tests,
 linter, type-checker, or program execution is performed once the
 source files have been modified.
 
+The implementation runs to *completion*: the skill never concludes
+while any point of the plan is still unimplemented, neither because the
+change set grew large nor because an open question stands in the way.
+Undecided details and defensible alternatives are therefore *decided by
+the skill itself*, guided by the surrounding artifacts and the
+internalized tenets, instead of interrupting the run with a question.
+Once the change set is applied, the run closes with up to two boxed
+summaries: `OPEN POINTS` lists everything now waiting for the user --
+points left unimplemented on a *genuine blocker* no assumption can
+bridge, follow-ups deliberately left out of scope with their reason,
+and results needing review -- and `DECISIONS` lists each decision the
+skill took on its own together with its rationale, so it can be
+revisited or overruled. Either box is omitted entirely when it has no
+content; a run which implemented every point and decided nothing on its
+own emits no box at all.
+
 After implementation, the user is asked whether to stop, hand off to
 `ase-task-edit`, hand off to `ase-task-integrate`, or delete the task
 plan, unless `--next` pre-selects this choice.

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

@@ -68,8 +68,8 @@ DEFERRED     INTEGRATING INTEGRATED CANCELLED
 -   `--include`|`-i`=*state*[`,`...]:
     Restrict the listed task plans to the given comma-separated list of
     lifecycle states (e.g. `IMPLEMENTING,STALLED`). Without this option,
-    all states are listed. The `none` sentinel selects no state at all,
-    the `finished` sentinel selects the finished states.
+    all states are listed. The `none` sentinel (the default) imposes no
+    restriction, the `finished` sentinel selects the finished states.
 
 -   `--exclude`|`-e`=*state*[`,`...]:
     Remove the given comma-separated list of lifecycle states from the