@rse/ase 0.9.54 → 0.9.55

package/dst/ase-log.js

@@ -12,6 +12,8 @@ const levels = [
     { name: "info", style: chalk.blue },
     { name: "debug", style: chalk.green }
 ];
+/*  check whether an arbitrary string is a valid log level  */
+export const isLogLevel = (level) => levels.some((l) => l.name === level);
 export default class Log {
     _program;
     _logLevel;
@@ -36,11 +38,14 @@ export default class Log {
         return stream;
     }
     logLevel(level) {
+        if (level === undefined)
+            return this._logLevel;
         const idx = levels.findIndex((l) => l.name === level);
         if (idx === -1)
             throw new RangeError(`invalid log level "${level}" (expected one of: ${levels.map((l) => l.name).join(", ")})`);
         this._logLevel = level;
         this.logLevelIdx = idx;
+        return this._logLevel;
     }
     logFile(file) {
         if (file === this._logFile)

package/dst/ase-service.js

@@ -16,6 +16,7 @@ import * as v from "valibot";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { Config, configSchema, ConfigMCP } from "./ase-config.js";
+import { isLogLevel } from "./ase-log.js";
 import { CompatMCP } from "./ase-compat.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
@@ -61,11 +62,18 @@ export const probe = async (port, projectId) => {
 };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
 const PORT_ENV = "ASE_SERVICE_PORT";
+const LEVEL_ENV = "ASE_SERVICE_LOG_LEVEL";
 const IDLE_MS = 30 * 60 * 1000;
 const TICK_MS = 60 * 1000;
 const PORT_MIN = 42000;
 const PORT_MAX = 44000;
 const PORT_TRIES = 20;
+/*  bounds for the append-only ".ase/service.log" file:
+    maximum tolerated size, number of tail lines surviving a trim,
+    and maximum length of the MCP tool call arguments logged per request  */
+const LOG_MAX_SIZE = 1024 * 1024;
+const LOG_KEEP_LINES = 2000;
+const LOG_ARGS_MAX = 200;
 /*  load the optional "config.yaml" and "service.yaml" files and derive
     the service identity context (project id, port, service config)  */
 export const loadServiceContext = (log) => {
@@ -130,15 +138,32 @@ export class Service {
                 svc.write();
         });
     }
+    /*  trim the log file down to its tail if it grew beyond the size limit  */
+    static trimLog(logFile) {
+        try {
+            if (!fs.existsSync(logFile) || fs.statSync(logFile).size <= LOG_MAX_SIZE)
+                return;
+            const tail = Service.readLogTail(logFile, LOG_KEEP_LINES);
+            fs.writeFileSync(logFile, tail.length > 0 ? `${tail}\n` : "");
+        }
+        catch {
+            /*  intentionally ignore all trimming errors, as a
+                non-trimmable log file must never block the service  */
+        }
+    }
     /*  spawn the current executable detached as a background service  */
-    static spawnDetached(aseDir, port) {
+    static spawnDetached(aseDir, port, logLevel) {
         fs.mkdirSync(aseDir, { recursive: true });
         const logFile = path.join(aseDir, "service.log");
+        /*  trim the log before handing it to the service, as the detached
+            service inherits the file descriptor for its entire lifetime and
+            hence cannot rotate the file itself while it is running  */
+        Service.trimLog(logFile);
         const fd = fs.openSync(logFile, "a");
         const entry = fileURLToPath(new URL("./ase.js", import.meta.url));
         const child = spawn(process.execPath, [entry, "service", "start"], {
             detached: true,
-            env: { ...process.env, [SERVE_ENV]: "1", [PORT_ENV]: String(port) },
+            env: { ...process.env, [SERVE_ENV]: "1", [PORT_ENV]: String(port), [LEVEL_ENV]: logLevel },
             stdio: ["ignore", fd, fd]
         });
         fs.closeSync(fd);
@@ -285,11 +310,20 @@ export default class ServiceCommand {
                 bodyInfo = ` [${bMethod}]`;
                 if (bName !== null) {
                     bodyInfo += ` ${bName}`;
-                    if (bArgs !== null)
-                        bodyInfo += ` ${JSON.stringify(bArgs)}`;
+                    if (bArgs !== null) {
+                        /*  cap the arguments, as payload-carrying tool calls
+                            (task plans, key/value batches, etc) would
+                            otherwise dominate the entire log file  */
+                        const args = JSON.stringify(bArgs);
+                        bodyInfo += ` ${args.length > LOG_ARGS_MAX ? `${args.slice(0, LOG_ARGS_MAX)}…` : args}`;
+                    }
                 }
             }
-            this.log.write("info", `mcp: ${request.method.toUpperCase()} ${request.path}${bodyInfo}`);
+            /*  log tool calls regularly, but all remaining MCP traffic
+                (session handshakes, notifications, SSE stream opens) at
+                debug level only, as it carries no diagnostic value  */
+            const level = bMethod === "tools/call" ? "info" : "debug";
+            this.log.write(level, `mcp: ${request.method.toUpperCase()} ${request.path}${bodyInfo}`);
             const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
             const mcp = buildMcpServer();
             request.raw.res.on("close", () => {
@@ -394,6 +428,11 @@ export default class ServiceCommand {
         const ctx = this.loadContext();
         let port = ctx.port;
         if (process.env[SERVE_ENV] === "1") {
+            /*  adopt the log level of the spawning process, as the
+                detached service is started without any CLI options  */
+            const level = process.env[LEVEL_ENV];
+            if (level !== undefined && isLogLevel(level))
+                this.log.logLevel(level);
             const raw = process.env[PORT_ENV];
             port = raw !== undefined ? Number(raw) : await Service.allocatePort();
             await this.runService({ ...ctx, port });
@@ -411,7 +450,7 @@ export default class ServiceCommand {
         let lastErr = new Error("service failed to start within timeout");
         for (let attempt = 0; attempt < 3; attempt++) {
             port = await Service.allocatePort();
-            const { child, logFile } = Service.spawnDetached(ctx.aseDir, port);
+            const { child, logFile } = Service.spawnDetached(ctx.aseDir, port, this.log.logLevel());
             let exited = false;
             let exitCode = null;
             let resolveExit = () => { };

package/dst/ase-task.js

@@ -14,6 +14,12 @@ import { LRUCache } from "lru-cache";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 import { Markdown } from "./ase-markdown.js";
 import { readStdin, writeStdout } from "./ase-stdio.js";
+/*  the lifecycle states a task plan can be in, i.e., the accepted
+    values of the "Status:" frontmatter key of a task plan  */
+export const taskStates = [
+    "DRAFTED", "REJECTED", "APPROVED", "DEFERRED",
+    "STARTED", "BLOCKED", "COMPLETED", "CANCELLED"
+];
 /*  reusable functionality: persisted task plans under
     <project>/<basedir>/TASK-<id>.md (driven by the
     "project.artifact.task.{basedir,files}" configuration)  */
@@ -141,12 +147,54 @@ export class Task {
         migrated.sort((a, b) => a.localeCompare(b));
         return migrated;
     }
-    /*  load a task; returns empty string if no task exists  */
+    /*  the legacy task plan header lines, each mapped onto the
+        frontmatter key which superseded it  */
+    static legacy = [
+        { key: "Created", re: /^⎈[ \t]+Created:[ \t]*(.*)$/m },
+        { key: "Modified", re: /^⚙[ \t]+Modified:[ \t]*(.*)$/m },
+        { key: "Kind", re: /^☯[ \t]+Kind:[ \t]*(.*)$/m }
+    ];
+    /*  render a single frontmatter line with a column-aligned key  */
+    static frontLine(key, value) {
+        return (key + ":").padEnd(12) + value;
+    }
+    /*  normalize a legacy task plan -- one carrying its metadata in the
+        "#   TASK <id>: <title>" heading and the "⎈"/"⚙"/"☯" glyph header
+        lines -- into the current Markdown frontmatter shape, so every
+        consumer sees a single plan shape only; a plan already carrying a
+        frontmatter block, and any content without a task heading at all,
+        is passed through verbatim -- in particular, absent optional keys
+        are never materialized, as they read as their default value  */
+    static normalize(id, text) {
+        if (text === "" || /^---\r?\n/.test(text))
+            return text;
+        const heading = /^#[ \t]+TASK(?:[ \t]+[A-Za-z0-9_-]+)?[ \t]*:[ \t]*(.*)$/m.exec(text);
+        if (heading === null)
+            return text;
+        /*  lift the glyph header lines into their frontmatter keys, with
+            the task id taken from the authoritative filename-derived id  */
+        let body = text.replace(heading[0], "");
+        const front = [Task.frontLine("Id", id)];
+        for (const legacy of Task.legacy) {
+            const m = legacy.re.exec(body);
+            if (m === null)
+                continue;
+            front.push(Task.frontLine(legacy.key, m[1].trim()));
+            body = body.replace(m[0], "");
+        }
+        /*  re-assemble the plan from the frontmatter block, the reduced
+            heading, and the body stripped of its now leading blank lines  */
+        return `---\n${front.join("\n")}\n---\n\n` +
+            `#   TASK: ${heading[1].trim()}\n\n` +
+            body.replace(/^(?:[ \t]*\r?\n)+/, "");
+    }
+    /*  load a task, normalized into the current Markdown frontmatter
+        shape; returns empty string if no task exists  */
     static load(log, id) {
         const file = Task.path(log, id);
         if (!fs.existsSync(file))
             return "";
-        return fs.readFileSync(file, "utf8");
+        return Task.normalize(id, fs.readFileSync(file, "utf8"));
     }
     /*  save a task as UTF-8 text under the given id into the
         <project>/<basedir>/TASK-<id>.md file  */
@@ -167,10 +215,11 @@ export class Task {
         return true;
     }
     /*  rename a task by moving its <project>/<basedir>/TASK-<oldId>.md file
-        to <project>/<basedir>/TASK-<newId>.md; the embedded
-        "#   TASK <id>:" heading inside the plan content is rewritten to
-        the new id; returns true on success, false if the source task does
-        not exist; throws if the target id already exists  */
+        to <project>/<basedir>/TASK-<newId>.md; the embedded "Id:"
+        frontmatter key inside the plan content is rewritten to the new id
+        (falling back to the "#   TASK <id>:" heading of a still legacy,
+        not yet normalized plan); returns true on success, false if the
+        source task does not exist; throws if the target id already exists  */
     static rename(log, oldId, newId) {
         const oldFile = Task.path(log, oldId);
         const newFile = Task.path(log, newId);
@@ -179,7 +228,9 @@ export class Task {
         if (fs.existsSync(newFile))
             throw new Error(`task: target id "${newId}" already exists`);
         const text = fs.readFileSync(oldFile, "utf8");
-        const updated = text.replace(/(^#\s+TASK\s+)[A-Za-z0-9_-]+(\s*:)/m, `$1${newId}$2`);
+        const updated = /^---\r?\n/.test(text) ?
+            text.replace(/^(Id:[ \t]*)[A-Za-z0-9_-]+[ \t]*$/m, `$1${newId}`) :
+            text.replace(/(^#\s+TASK\s+)[A-Za-z0-9_-]+(\s*:)/m, `$1${newId}$2`);
         fs.mkdirSync(path.dirname(newFile), { recursive: true });
         fs.writeFileSync(newFile, updated, "utf8");
         fs.rmSync(oldFile, { force: true });
@@ -207,17 +258,55 @@ export class Task {
         }
         return out;
     }
-    /*  list all persisted tasks in lexicographic id order; if verbose is true,
-        each entry's `mtime` is set to the task file's modification time
-        formatted as "YYYY-MM-DD HH:MM", otherwise it is left undefined  */
+    /*  read the "Status:" frontmatter key of a task plan file, falling back
+        to the "DRAFTED" default of the task plan format for a plan whose
+        frontmatter is absent or carries no such key  */
+    static status(file) {
+        const fm = /^---\r?\n([\s\S]*?\r?\n)---\r?\n/.exec(fs.readFileSync(file, "utf8"));
+        if (fm === null)
+            return "DRAFTED";
+        const m = /^Status:[ \t]*(\S+)[ \t]*$/m.exec(fm[1]);
+        if (m === null)
+            return "DRAFTED";
+        return m[1];
+    }
+    /*  list all persisted tasks in lexicographic id order, each with the
+        `status` of its plan; if verbose is true, each entry's `mtime` is
+        set to the task file's modification time formatted as
+        "YYYY-MM-DD HH:MM", otherwise it is left undefined  */
     static list(log, verbose = false) {
         const out = Task.scan(log).map((entry) => ({
             id: entry.id,
+            status: Task.status(entry.file),
             mtime: verbose ? DateTime.fromJSDate(entry.st.mtime).toFormat("yyyy-LL-dd HH:mm") : undefined
         }));
         out.sort((a, b) => a.id.localeCompare(b.id));
         return out;
     }
+    /*  resolve an "include" and an "exclude" comma-separated lifecycle
+        state list into the effective state set a task plan has to be in
+        to be listed at all; the "none" sentinel and empty tokens are
+        silently dropped, an empty "include" list means all states, and
+        the "exclude" list is applied after the "include" list  */
+    static states(include, exclude) {
+        const parse = (list) => list.split(",")
+            .map((token) => token.trim())
+            .filter((token) => token !== "" && token.toUpperCase() !== "NONE")
+            .map((token) => {
+            const state = token.toUpperCase();
+            if (!taskStates.includes(state))
+                throw new Error(`task: invalid state "${token}" ` +
+                    `(expected one of: ${taskStates.join(", ")})`);
+            return state;
+        });
+        const included = parse(include);
+        const excluded = parse(exclude);
+        const states = (included.length > 0 ? included : taskStates)
+            .filter((state) => !excluded.includes(state));
+        if (states.length === 0)
+            throw new Error("task: options \"--include\" and \"--exclude\" cancel out to an empty state set");
+        return states;
+    }
     /*  purge tasks whose modification time is older than the given cutoff in
         milliseconds; returns the list of removed task ids  */
     static purge(log, maxAgeMs) {
@@ -274,12 +363,19 @@ export default class TaskCommand {
         task
             .command("list")
             .description("List all persisted task ids, one per line")
-            .option("-v, --verbose", "also show the task file modification time as (YYYY-MM-DD HH:MM)")
+            .option("-v, --verbose", "also show the task plan status and the task file " +
+            "modification time as (YYYY-MM-DD HH:MM)")
+            .option("-i, --include <states>", "comma-separated list of lifecycle states to list " +
+            `(${taskStates.join("|")}), or "none" for no restriction`, "none")
+            .option("-e, --exclude <states>", "comma-separated list of lifecycle states to not list " +
+            `(${taskStates.join("|")}), or "none" for no exclusion`, "COMPLETED,CANCELLED")
             .action(async (opts) => {
-            const items = Task.list(this.log, opts.verbose ?? false);
+            const states = Task.states(opts.include, opts.exclude);
+            const items = Task.list(this.log, opts.verbose ?? false)
+                .filter((item) => states.includes(item.status));
             for (const item of items) {
                 if (opts.verbose)
-                    await writeStdout(`${item.id}\t(${item.mtime})\n`);
+                    await writeStdout(`${item.id}\t${item.status}\t(${item.mtime})\n`);
                 else
                     await writeStdout(`${item.id}\n`);
             }
@@ -395,7 +491,8 @@ export class TaskMCP {
             title: "ASE task list",
             description: "List all persisted tasks. " +
                 "Returns a `tasks` array (in lexicographic `id` order) where each item has the " +
-                "task `id`. If `verbose` is `true`, each item additionally has an `mtime` field " +
+                "task `id` and the `status` of its plan (the `Status:` frontmatter key, defaulting " +
+                "to `DRAFTED`). If `verbose` is `true`, each item additionally has an `mtime` field " +
                 "(last modification time of the task's `TASK-<id>.md` file, formatted as `YYYY-MM-DD HH:MM`). " +
                 "Returns an empty array if no tasks exist.",
             inputSchema: {
@@ -405,6 +502,7 @@ export class TaskMCP {
             outputSchema: {
                 tasks: z.array(z.object({
                     id: z.string().describe("task identifier"),
+                    status: z.string().describe("task plan lifecycle status (`Status:` frontmatter key, default `DRAFTED`)"),
                     mtime: z.string().optional()
                         .describe("`TASK-<id>.md` modification time (`YYYY-MM-DD HH:MM`); only present if `verbose` is true")
                 })).describe("all persisted tasks in lexicographic id order")
@@ -414,8 +512,8 @@ export class TaskMCP {
                 const verbose = args.verbose ?? false;
                 const items = Task.list(this.log, verbose);
                 const tasks = verbose ?
-                    items.map((item) => ({ id: item.id, mtime: item.mtime ?? "" })) :
-                    items.map((item) => ({ id: item.id }));
+                    items.map((item) => ({ id: item.id, status: item.status, mtime: item.mtime ?? "" })) :
+                    items.map((item) => ({ id: item.id, status: item.status }));
                 const result = { tasks };
                 return {
                     structuredContent: result,
@@ -430,7 +528,8 @@ export class TaskMCP {
         mcp.registerTool("ase_task_load", {
             title: "ASE task load",
             description: "Load a previously persisted task by `id`. " +
-                "Returns the task as `text`; returns an empty string if no task exists for the `id`.",
+                "Returns the task as `text`, normalized into the current Markdown frontmatter shape; " +
+                "returns an empty string if no task exists for the `id`.",
             inputSchema: {
                 id: z.string()
                     .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
@@ -501,7 +600,7 @@ export class TaskMCP {
         mcp.registerTool("ase_task_rename", {
             title: "ASE task rename",
             description: "Rename a previously persisted task from `old` to `new` by moving the " +
-                "task `TASK-<id>.md` file and rewriting its embedded task heading. " +
+                "task `TASK-<id>.md` file and rewriting its embedded `Id:` frontmatter key. " +
                 "Returns a status `text` indicating whether the rename succeeded. " +
                 "Fails with an error if the target id already exists.",
             inputSchema: {

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.54",
+    "version":                              "0.9.55",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.55",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.55",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.55",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/meta/ase-common-code.md

@@ -15,7 +15,7 @@ and updating of code. Do not output anything.
 Determine the *kind of change* the task plan describes and internalize
 the corresponding tenet sets:
 
--   If <task-content/> contains a `☯   Kind:     <text/>` header line
+-   If the frontmatter of <task-content/> carries a `Kind: <text/>` key
     and <text/> is one of `CRAFTING`, `REFACTORING`, or `RESOLVING`:
     Set <task-kind><text/></task-kind> (set task kind to the stated kind).
 

package/plugin/meta/ase-common-task.md

@@ -103,11 +103,12 @@ 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. If
 <timestamp-created/> is still unset (because the plan content
-had no `Created:` line), set
+had no `Created:` frontmatter key), set
 <timestamp-created><timestamp-modified/></timestamp-created>
 (fall back to the modified timestamp). Re-insert the current
 <ase-task-id/>, the original <timestamp-created/>, and the
-refreshed <timestamp-modified/> into <task-content/> and calculate
+refreshed <timestamp-modified/> into the frontmatter keys `Id:`,
+`Created:`, and `Modified:` of <task-content/> and calculate
 the number of words <words/> of <task-content/>.
 
 Call the `ase_task_save(id: "<ase-task-id/>", text:

package/plugin/meta/ase-format-task.md

@@ -5,12 +5,16 @@ Task
 Every *task* uses a strict and fixed format:
 
 <format>
+---
+Id:         <task-id/>
+Created:    <timestamp-created/>
+Modified:   <timestamp-modified/>
+Status:     <task-status/>
+Properties: <task-properties/>
+Kind:       <task-kind/>
+---
 
-#   TASK <task-id/>: <title/>
-
-⎈   Created:  <timestamp-created/>
-⚙   Modified: <timestamp-modified/>
-☯   Kind:     <task-kind/>
+#   TASK: <title/>
 
 ##  CONTEXT
 
@@ -34,8 +38,19 @@ Every *task* uses a strict and fixed format:
 
 You *MUST* honor the following hints on this *task* format:
 
--   You *MUST* always keep the first empty line and the last empty line.
-    If one of them is missing, add it back.
+-   The content *MUST* begin with the `---` opening delimiter of the
+    *Markdown frontmatter* as its very *first* line -- there is *no*
+    leading empty line, as any line before the `---` would degrade the
+    frontmatter into ordinary Markdown. You *MUST* always keep the empty
+    line between the closing `---` delimiter and the `#` heading, and
+    always keep the last empty line. If one of them is missing, add it
+    back.
+
+-   The *frontmatter* carries the keys `Id`, `Created`, `Modified`,
+    `Status`, `Properties`, and `Kind`, in exactly this order, with their
+    values being *unquoted* plain scalars and vertically aligned one
+    space after the longest key. Only `Id` is *mandatory* -- every other
+    key is *optional* and, when absent, falls back to its default value.
 
 -   In all descriptions, highlight *code* as
     <template>`<code/>`</template> and *key aspects* as
@@ -47,25 +62,80 @@ You *MUST* honor the following hints on this *task* format:
     is changed, what benefit results or what the rationale is behind the
     change.
 
--   The <task-id/> has to be substituted with the current value of
-    <ase-task-id/> in the current session context.
-
--   The `☯   Kind:` line states the *kind of change* the task plan
+-   The <task-id/> of the `Id:` frontmatter key has to be substituted
+    with the current value of <ase-task-id/> in the current session
+    context.
+
+-   The `Status:` frontmatter key states the current *lifecycle state*
+    of the task plan. The key is *optional* and defaults to `DRAFTED`:
+    an *absent* key reads as `DRAFTED`, and a *newly created* plan
+    carries `DRAFTED` explicitly. The <task-status/> value is *strictly*
+    one of the following eight states:
+
+    -   `DRAFTED`: plan exists but is still provisional and not yet
+        cleared for implementation.
+    -   `REJECTED`: plan was reviewed and refused, and has to be reworked
+        before it can be approved.
+    -   `APPROVED`: plan is accepted as authoritative and cleared for
+        implementation, but no work has begun.
+    -   `DEFERRED`: plan is approved and unobstructed, but its start was
+        deliberately postponed.
+    -   `STARTED`: implementation of the plan is actively underway.
+    -   `BLOCKED`: implementation is halted by an impediment which
+        someone has to remove before it can resume.
+    -   `COMPLETED`: plan was implemented in full and reached its
+        intended outcome.
+    -   `CANCELLED`: plan was terminated before completion, because it
+        failed, was called off, or became obsolete.
+
+-   The eight states form a *state machine*. Whoever sets the `Status:`
+    key *MUST* only move along one of the following transitions, whereby
+    a *single* operation *MAY* traverse *several* transitions at once if
+    it performs the corresponding stages in one go:
+
+    ```text
+    DRAFTED   ──reject───▶ REJECTED      STARTED   ──block────▶ BLOCKED
+    REJECTED  ──redraft──▶ DRAFTED       BLOCKED   ──unblock──▶ STARTED
+    DRAFTED   ──approve──▶ APPROVED      STARTED   ──complete─▶ COMPLETED
+    APPROVED  ──defer────▶ DEFERRED
+    DEFERRED  ──resume───▶ APPROVED      any non-terminal state
+    APPROVED  ──start────▶ STARTED       ──cancel───▶ CANCELLED
+    ```
+
+    `COMPLETED` and `CANCELLED` are the two *terminal* states: a plan
+    which reached one of them is *finished* and leaves the state machine.
+
+-   The `Properties:` frontmatter key states which *stages* the task
+    plan already passed through. The <task-properties/> value is
+    *strictly* either `none` or a comma-separated list of the values
+    `grilled`, `preflighted`, `implemented`, and `verified`, listed in
+    exactly this order, each at most once. The key is *optional* and
+    defaults to `none`: an *absent* key reads as `none`, and a *newly
+    created* plan carries `none` explicitly. The list only ever
+    *accumulates*: a skill *adds* its own value if still absent and
+    *MUST NOT* drop any value already present, except when a plan is
+    *recreated from scratch*, which resets it to `none`.
+
+-   The `Kind:` frontmatter key states the *kind of change* the task plan
     describes, and hence which *operation-specific tenet set* of the
     **ASE Tenets** a subsequent preflight or implementation has to
     honor. The <task-kind/> value is *strictly* one of `CRAFTING`,
-    `REFACTORING`, or `RESOLVING`, and the line is column-aligned with
-    the `⎈   Created:` and `⚙   Modified:` lines above it.
+    `REFACTORING`, or `RESOLVING`.
 
--   The `☯   Kind:` line is *optional*: a skill *authoring* or
-    *updating* a task plan *CAN* update an already present line or pass
+-   The `Kind:` frontmatter key is *optional*: a skill *authoring* or
+    *updating* a task plan *CAN* update an already present key or pass
     it through *verbatim* and *MAY* create a missing one by *inferring*
     the kind from the plan content (defaulting to `CRAFTING`). A
-    `--dry` run *never* drops this line, as `--dry` only omits the
+    `--dry` run *never* drops this key, as `--dry` only omits the
     `##  VERIFICATION` section.
 
--   The <timestamp-created/> is the timestamp when this task plan was
-    created. The <timestamp-modified/> is the timestamp when this
+-   A skill *writing* an optional key which is still *absent* inserts it
+    at its position in the key order above and re-aligns the values of
+    the whole frontmatter block.
+
+-   The <timestamp-created/> of the `Created:` frontmatter key is the
+    timestamp when this task plan was created. The <timestamp-modified/>
+    of the `Modified:` frontmatter key is the timestamp when this
     task plan was last modified. Both use an ISO-style format
     value. The value of both can be determined by a call to the
     `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase` MCP

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.54",
+    "version":                              "0.9.55",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-code-lint/help.md

@@ -64,8 +64,8 @@ A05 COMPLEXITY     A10 SMELLS           A15 PERFORMANCE     A20 DEAD-CODE
 
 `--exclude`|`-e`=*aspect*[`,`...]:
     Remove the given comma-separated list of aspect ids from the checked
-    code quality aspects. Applied *after* `--include`, so `-i A01,A02 -e
-    A02` checks `A01` only.
+    code quality aspects. Applied *after* `--include`, so
+    `-i A01,A02 -e A02` checks `A01` only.
 
 ##  ARGUMENTS
 

package/plugin/skills/ase-meta-config/help.md

@@ -67,9 +67,9 @@ The following *operations* exist:
 The `init` and `edit` subcommands of the `ase config` CLI are
 deliberately *not* mirrored: `edit` is bound to the interactive `$EDITOR`
 and therefore has no meaning inside an assistant turn, and `init` is a
-preset-bootstrapping operation that stays a shell concern next to `ase
-setup`. Both remain available as `ase config init` and `ase config edit`
-on the command line.
+preset-bootstrapping operation that stays a shell concern next to
+`ase setup`. Both remain available as `ase config init` and
+`ase config edit` on the command line.
 
 ##  OPTIONS
 

package/plugin/skills/ase-meta-quotes/help.md

@@ -39,9 +39,10 @@ without any quote is rendered as `(none)`.
 
 Every quote is rendered on its own line and carries, where applicable,
 the suffixes `— <author>, <origin>` (in the two `ATTRIBUTED`
-quadrants, omitting whichever part is unknown), `[from proximity:
-<source-topic>]` (when the quote was contributed by a neighborhood topic
-under `--proximity` instead of by *topic-keywords* itself), and
+quadrants, omitting whichever part is unknown),
+`[from proximity: <source-topic>]` (when the quote was contributed by a
+neighborhood topic under `--proximity` instead of by *topic-keywords*
+itself), and
 `(unverified)` (when the exact wording or the attribution could not be
 established with confidence). The `(unverified)` marker is dropped as
 soon as the Internet/Web search under `--ground` confirms the wording and

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

@@ -98,7 +98,7 @@ Set <args></args> (set args to empty).
         Set <words-before><words/></words-before> (remember the loaded
         word count for the strictly-smaller check in step 3).
 
-        <if condition="<task-content/> contains '⎈   Created:  <text/>'">
+        <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
         Set <timestamp-created><text/></timestamp-created> (extract the
         original creation timestamp so it can be re-inserted unchanged
         into the condensed <task-content/> in step 3).
@@ -125,10 +125,11 @@ Set <args></args> (set args to empty).
         and unchanged*. Honor the following ruleset *strictly*:
 
         1.  *Preserve-exactly (never alter)*: the plan <format/>
-            structure (the headings `#`/`##`, all three `##  CONTEXT`,
-            `##  CHANGES`, and `##  VERIFICATION` sections, the
-            `Created:`/`Modified:` lines, and
-            the `- **<aspect/>**:` bullet labels), all *code spans* and
+            structure (the frontmatter block with its `Id:`, `Created:`,
+            `Modified:`, `Status:`, `Properties:`, and `Kind:` keys,
+            the headings `#`/`##`, all
+            three `##  CONTEXT`, `##  CHANGES`, and `##  VERIFICATION`
+            sections, and the `- **<aspect/>**:` bullet labels), all *code spans* and
             code blocks, technical terms, file paths, identifiers,
             numbers, severities (`LOW`/`MEDIUM`/`HIGH`/`ACCEPTED`), and
             the `*<aspect/>*` emphasis highlighting convention.

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

@@ -30,7 +30,7 @@ telegrapher-like even under the `writer` persona.
 
 The plan is saved *only* when condensing actually makes it smaller; if no
 further reduction is possible, the plan is left untouched (including its
-`⚙   Modified:` timestamp) and reported as *already condensed*.
+`Modified:` frontmatter timestamp) and reported as *already condensed*.
 
 After condensing, the user is asked whether to stop or hand off to
 `ase-task-edit`, `ase-task-implement`, or `ase-task-preflight`, unless

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

@@ -322,13 +322,13 @@ Set <args></args> (set args to empty).
     `PREFLIGHT`, or declines/cancels in the dialog of step 3.4:
 
     1.  *Update timestamp*:
-        <if condition="<task-content/> contains '⚙   Modified:' AND <task-content-dirty/> is 'true'">
+        <if condition="the frontmatter of <task-content/> carries a `Modified:` key AND <task-content-dirty/> is 'true'">
         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/>`.
+        the `Modified: ...` frontmatter key of <task-content/> with the
+        new <timestamp-modified/> value.
         Do not output anything.
         </if>
 
@@ -346,6 +346,27 @@ Set <args></args> (set args to empty).
         </if>
 
     3.  *Render plan*: 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>
+
         Only output the following <template/>, so the user
         can read the plan and react to it. If <task-content/> is longer
         than 90 lines and a `##  IMPLEMENTATION DRAFT` section (from the
@@ -355,9 +376,9 @@ Set <args></args> (set args to empty).
         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>
 
     4.  *Determine next step*:

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

@@ -216,7 +216,7 @@ Set <args>--int-reuse-task</args>.
 
     2.  Finally, update the plan in <plan/> based on all answers <answer-N/>.
 
-    3.  <if condition="<plan/> contains '⎈   Created:  <text/>'">
+    3.  <if condition="the frontmatter of <plan/> carries a `Created: <text/>` key">
         Set <timestamp-created><text/></timestamp-created> (set
         timestamp-created to extracted text)
         </if>
@@ -225,11 +225,15 @@ Set <args>--int-reuse-task</args>.
         `ase` MCP server and use the `text` field of its response for
         <timestamp-modified/> information. If <timestamp-created/> is
         still unset (because the previous <plan/> had no `Created:`
-        line), set <timestamp-created><timestamp-modified/></timestamp-created>
+        frontmatter key), set <timestamp-created><timestamp-modified/></timestamp-created>
         (fall back to the modified timestamp). Then insert the current
         <ase-task-id/>, previous <timestamp-created/>, and refreshed
-        <timestamp-modified/> information and calculate the number of
-        words <words/> of <plan/>.
+        <timestamp-modified/> information into the frontmatter keys `Id:`,
+        `Created:`, and `Modified:` and calculate the number of
+        words <words/> of <plan/>. Additionally *add* the value `grilled`
+        to the `Properties:` frontmatter key if it is still absent,
+        keeping all already present values and *creating* the whole key
+        (with the single value `grilled`) if the plan carries none.
 
     5.  Call the `ase_task_save(id: "<ase-task-id/>",
         text: "<plan/>")` tool of the `ase` MCP server to save the updated

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

@@ -24,7 +24,8 @@ the code base and world knowledge), marks the current-plan choice, and
 lets the user pick via an interactive dialog. It honors checks for
 *fuzzy language*, *conflicting terminology*, *conflicting code*, and
 *non-concrete scenarios*. Once all aspects are resolved, the plan is
-updated and persisted, and the user is offered a hand-off to editing,
+updated and persisted, its `Properties:` frontmatter key gains the value
+`grilled`, and the user is offered a hand-off to editing,
 implementation, or preflight.
 
 ##  OPTIONS

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

@@ -189,13 +189,42 @@ 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 `start` and `complete` transitions of the
+            state machine of the plan <format/> in one go. 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.
+
+        Then 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

@@ -17,13 +17,17 @@ 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.
+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:` 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 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,40 @@ 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>
+
+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 +72,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 +99,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 +108,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 +121,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

@@ -88,16 +88,22 @@ Procedure
 
         </template>
 
-    3.  <if condition="<task-content/> contains '⚙   Modified:'">
+    3.  <if condition="the frontmatter of <task-content/> carries a `Modified:` key">
         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/>`.
+        the `Modified: ...` frontmatter key of <task-content/> with the
+        new <timestamp-modified/> value.
         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
         task plan content. Calculate the number of words <words/> of

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

@@ -126,7 +126,7 @@ Procedure
         (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)
         </if>

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

@@ -78,6 +78,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 +108,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>