@rse/ase 0.9.55 → 0.9.56

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

@@ -78,25 +78,31 @@ 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="the frontmatter of <task-content/> carries a `Modified:` key">
-        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
+        MCP server and using the `text` field of its response. Update
         the `Modified: ...` frontmatter key of <task-content/> with the
-        new <timestamp-modified/> value.
+        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

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="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.
 

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}` }]
-                };
-            }
-        });
-    }
-}

package/dst/ase-persona.js

@@ -1,87 +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 persona style get/set  */
-export class Persona {
-    /*  allowed persona style values  */
-    static styles = agentClassification.persona;
-    /*  get the effective persona style for an optional session;
-        returns the default "engineer" 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.persona");
-        if (val === undefined)
-            return "engineer";
-        const style = String(isScalar(val) ? val.value : val);
-        return Persona.styles.find((s) => s === style) ?? "engineer";
-    }
-    /*  set the persona style on the strongest scope of an optional session  */
-    static set(log, style, session) {
-        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
-        const cfg = new Config("config", configSchema, log, scope);
-        cfg.lock(() => {
-            cfg.read();
-            cfg.set("agent.persona", style);
-            cfg.write();
-        });
-    }
-}
-/*  MCP registration entry point for persona tools  */
-export default class PersonaMCP {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    register(mcp) {
-        mcp.registerTool("ase_persona", {
-            title: "ASE persona style get/set",
-            description: "Get or set the active ASE agent persona `style`. " +
-                "If `style` is provided, it sets the persona style, " +
-                "otherwise it returns the current persona `style`. " +
-                "If `session` is provided, the operation is scoped to that session, " +
-                "otherwise it operates on the strongest/closest scope (user/project cascade). " +
-                "Allowed styles: \"writer\" (decorative, eloquent, explaining), " +
-                "\"engineer\" (concise, factual, accurate), " +
-                "\"journalist\" (layered, pyramid-structured title/core/detail), " +
-                "\"telegrapher\" (very brief, factual, abbreviating), " +
-                "\"caveman\" (ultra brief, rough, stuttering).",
-            inputSchema: {
-                style: z.enum(Persona.styles).optional()
-                    .describe("persona style to set; if omitted, the current persona style 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.style !== undefined) {
-                    Persona.set(this.log, args.style, args.session);
-                    const where = args.session !== undefined ?
-                        ` for session "${args.session}"` : "";
-                    const msg = `OK: set agent.persona to "${args.style}"${where}`;
-                    return {
-                        content: [{ type: "text", text: msg }]
-                    };
-                }
-                const text = Persona.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}` }]
-                };
-            }
-        });
-    }
-}

package/dst/ase-stdout.js

@@ -1,18 +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>
-*/
-/*  write a string to stdout, awaiting the write callback which only
-    fires once the data has been flushed to the underlying pipe, so a
-    subsequent "process.exit" cannot truncate the output  */
-export const writeStdout = (text) => {
-    return new Promise((resolve, reject) => {
-        process.stdout.write(text, (err) => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
-};