@rse/ase 0.0.17 → 0.0.19

package/dst/ase-config.js

@@ -13,100 +13,45 @@ import * as v from "valibot";
 import Table from "cli-table3";
 /*  classification taxonomy  */
 export const projectClassification = {
-    source: {
-        ambition: ["artist", "craftsman", "engineer"],
-        boxing: ["white", "grey", "black"],
-        size: ["small", "medium", "large"],
-        structure: ["bare", "library", "framework"]
-    },
-    process: {
-        actors: ["person", "team", "crew"],
-        drive: ["spec", "code", "test"]
-    },
-    result: {
-        target: ["prototype", "mvp", "product"]
-    }
+    boxing: ["white", "grey", "black"]
 };
 /*  agent classification taxonomy  */
 export const agentClassification = {
-    persona: {
-        style: ["writer", "engineer", "telegrapher", "caveman"],
-        creativity: ["none", "lite", "full"]
-    },
-    process: {
-        autonomy: ["assistant", "hotl", "agent"]
-    }
+    persona: ["writer", "engineer", "telegrapher", "caveman"]
 };
 /*  classification presets  */
 export const projectClassificationPresets = {
     vibe: {
         "project.id": "example",
         "project.name": "Example Project",
-        "project.source.ambition": "engineer",
-        "project.source.boxing": "black",
-        "project.source.size": "small",
-        "project.source.structure": "bare",
-        "project.process.actors": "person",
-        "project.process.drive": "spec",
-        "project.result.target": "prototype",
-        "agent.persona.style": "writer",
-        "agent.persona.creativity": "full",
-        "agent.process.autonomy": "agent"
+        "project.boxing": "black",
+        "agent.persona": "writer"
     },
     pro: {
         "project.id": "example",
         "project.name": "Example Project",
-        "project.source.ambition": "artist",
-        "project.source.boxing": "white",
-        "project.source.size": "medium",
-        "project.source.structure": "framework",
-        "project.process.actors": "person",
-        "project.process.drive": "code",
-        "project.result.target": "product",
-        "agent.persona.style": "engineer",
-        "agent.persona.creativity": "none",
-        "agent.process.autonomy": "assistant"
+        "project.boxing": "white",
+        "agent.persona": "engineer"
     },
     default: {
         "project.id": "example",
         "project.name": "Example Project",
-        "project.source.ambition": "artist",
-        "project.source.boxing": "white",
-        "project.source.size": "medium",
-        "project.source.structure": "framework",
-        "project.process.actors": "person",
-        "project.process.drive": "code",
-        "project.result.target": "product",
-        "project.artifact.build": "{etc/**,README.md,AGENTS.md,LICENSE.txt,package.json}",
-        "project.artifact.code": "src/**/*",
-        "project.artifact.docs": "doc/user/**/*.md",
-        "project.artifact.spec": "doc/spec/**/*.md",
-        "project.artifact.arch": "doc/arch/**/*.md",
-        "agent.persona.style": "engineer",
-        "agent.persona.creativity": "none",
-        "agent.process.autonomy": "assistant",
-        "task.id": "default"
+        "project.boxing": "white",
+        "agent.persona": "engineer",
+        "agent.task": "default"
     },
     industry: {
         "project.id": "example",
         "project.name": "Example Project",
-        "project.source.ambition": "craftsman",
-        "project.source.boxing": "grey",
-        "project.source.size": "large",
-        "project.source.structure": "framework",
-        "project.process.actors": "crew",
-        "project.process.drive": "code",
-        "project.result.target": "mvp",
-        "agent.persona.style": "engineer",
-        "agent.persona.creativity": "none",
-        "agent.process.autonomy": "hotl"
+        "project.boxing": "grey",
+        "agent.persona": "engineer"
     }
 };
 /*  hard-coded map: which scope kinds each variable may be SET on
     (reads always cascade through the full chain, this restricts writes only);
     keys absent from this map default to all non-"default" scope kinds  */
 export const configWritableScopes = {
-    "task.id": ["session"]
+    "agent.task": ["session"]
 };
 /*  default set of scope kinds writable for any unrestricted key  */
 const configWritableScopesDefault = ["user", "project", "task", "session"];
@@ -181,38 +126,11 @@ export const configSchema = v.nullish(v.strictObject({
     project: v.optional(v.strictObject({
         id: v.optional(v.pipe(v.string(), v.minLength(1))),
         name: v.optional(v.pipe(v.string(), v.minLength(1))),
-        source: v.optional(v.strictObject({
-            ambition: v.optional(v.picklist(projectClassification.source.ambition)),
-            boxing: v.optional(v.picklist(projectClassification.source.boxing)),
-            size: v.optional(v.picklist(projectClassification.source.size)),
-            structure: v.optional(v.picklist(projectClassification.source.structure))
-        })),
-        process: v.optional(v.strictObject({
-            actors: v.optional(v.picklist(projectClassification.process.actors)),
-            drive: v.optional(v.picklist(projectClassification.process.drive))
-        })),
-        result: v.optional(v.strictObject({
-            target: v.optional(v.picklist(projectClassification.result.target))
-        })),
-        artifact: v.optional(v.strictObject({
-            build: v.optional(v.pipe(v.string(), v.minLength(1))),
-            code: v.optional(v.pipe(v.string(), v.minLength(1))),
-            docs: v.optional(v.pipe(v.string(), v.minLength(1))),
-            spec: v.optional(v.pipe(v.string(), v.minLength(1))),
-            arch: v.optional(v.pipe(v.string(), v.minLength(1)))
-        }))
+        boxing: v.optional(v.picklist(projectClassification.boxing))
     })),
     agent: v.optional(v.strictObject({
-        persona: v.optional(v.strictObject({
-            style: v.optional(v.picklist(agentClassification.persona.style)),
-            creativity: v.optional(v.picklist(agentClassification.persona.creativity))
-        })),
-        process: v.optional(v.strictObject({
-            autonomy: v.optional(v.picklist(agentClassification.process.autonomy))
-        }))
-    })),
-    task: v.optional(v.strictObject({
-        id: v.optional(v.pipe(v.string(), v.minLength(1)))
+        persona: v.optional(v.picklist(agentClassification.persona)),
+        task: v.optional(v.pipe(v.string(), v.minLength(1)))
     }))
 }));
 /*  encapsulate read/write access to a stack of "<name>.yaml" configuration files,

package/dst/ase-hook.js

@@ -80,7 +80,7 @@ export default class HookCommand {
         /*  determine task id  */
         const taskId = process.env.ASE_TASK_ID ?? "default";
         try {
-            cfg.set("task.id", taskId);
+            cfg.set("agent.task", taskId);
             cfg.write();
         }
         catch (_e) {
@@ -103,8 +103,8 @@ export default class HookCommand {
         /*  determine user id  */
         const userId = process.env.USER ?? process.env.LOGNAME ?? "unknown";
         /*  determine agent persona style  */
-        let persona = "engineer";
-        const val = cfg.get("agent.persona.style");
+        let persona = process.env.ASE_PERSONA_STYLE ?? "engineer";
+        const val = cfg.get("agent.persona");
         if (typeof val === "string")
             persona = val;
         /*  provide ASE information to Claude Code shell commands  */

package/dst/ase-plan.js

@@ -0,0 +1,143 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+/*  validate the plan id to keep it safe as a filename component  */
+const validateId = (id) => {
+    if (typeof id !== "string" || id.length === 0)
+        throw new Error("plan: id must be a non-empty string");
+    if (!/^[A-Za-z0-9-]+$/.test(id))
+        throw new Error("plan: id must match [A-Za-z0-9-]+");
+};
+/*  resolve the on-disk path for a given plan id  */
+const planPath = (id) => {
+    validateId(id);
+    return path.join(os.homedir(), ".ase", "plan", `${id}.md`);
+};
+/*  load a plan; returns empty string if no plan exists  */
+export const planLoad = (id) => {
+    const file = planPath(id);
+    if (!fs.existsSync(file))
+        return "";
+    return fs.readFileSync(file, "utf8");
+};
+/*  save a plan as UTF-8 text under the given id  */
+export const planSave = (id, text) => {
+    if (typeof text !== "string")
+        throw new Error("plan: text must be a string");
+    const file = planPath(id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text, "utf8");
+};
+/*  delete a plan by id; returns true if a plan existed and was removed  */
+export const planDelete = (id) => {
+    const file = planPath(id);
+    if (!fs.existsSync(file))
+        return false;
+    fs.rmSync(file);
+    return true;
+};
+/*  purge plans whose modification time is older than the given cutoff in
+    milliseconds; returns the list of removed plan ids  */
+export const planPurge = (maxAgeMs) => {
+    const dir = path.join(os.homedir(), ".ase", "plan");
+    if (!fs.existsSync(dir))
+        return [];
+    const cutoff = Date.now() - maxAgeMs;
+    const removed = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const file = path.join(dir, entry);
+        const st = fs.statSync(file);
+        if (!st.isFile())
+            continue;
+        if (st.mtimeMs < cutoff) {
+            fs.rmSync(file);
+            removed.push(entry.slice(0, -3));
+        }
+    }
+    return removed;
+};
+/*  read all of stdin as a UTF-8 string  */
+const readStdin = () => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", (err) => reject(err));
+    });
+};
+/*  CLI command "ase plan"  */
+export default class PlanCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register commands  */
+    register(program) {
+        /*  register CLI top-level command "ase plan"  */
+        const plan = program
+            .command("plan")
+            .description("Manage persisted plans under ~/.ase/plan/<id>.md")
+            .action(() => {
+            plan.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase plan load"  */
+        plan
+            .command("load")
+            .description("Load a plan by id and write it to stdout")
+            .argument("<id>", "Plan identifier")
+            .action((id) => {
+            const text = planLoad(id);
+            process.stdout.write(text);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase plan save"  */
+        plan
+            .command("save")
+            .description("Save a plan by id, reading content from stdin")
+            .argument("<id>", "Plan identifier")
+            .action(async (id) => {
+            const text = await readStdin();
+            planSave(id, text);
+            this.log.write("info", `plan: saved "${id}"`);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase plan delete"  */
+        plan
+            .command("delete")
+            .description("Delete a plan by id")
+            .argument("<id>", "Plan identifier")
+            .action((id) => {
+            const removed = planDelete(id);
+            if (removed)
+                this.log.write("info", `plan: removed "${id}"`);
+            else
+                this.log.write("info", `plan: no plan "${id}" to remove`);
+            process.exit(removed ? 0 : 1);
+        });
+        /*  register CLI sub-command "ase plan purge"  */
+        plan
+            .command("purge")
+            .description("Remove all plans with a modification time older than <days> (default: 31)")
+            .argument("[<days>]", "Maximum plan age in days", "31")
+            .action((days) => {
+            const n = Number.parseInt(days, 10);
+            if (!Number.isFinite(n) || n < 0)
+                throw new Error("plan: <days> must be a non-negative integer");
+            const removed = planPurge(n * 24 * 60 * 60 * 1000);
+            if (removed.length === 0)
+                this.log.write("info", "plan: no plans to purge");
+            else
+                for (const id of removed)
+                    this.log.write("info", `plan: purged "${id}"`);
+            process.exit(0);
+        });
+    }
+}

package/dst/ase-service.js

@@ -10,14 +10,15 @@ import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import Hapi from "@hapi/hapi";
 import axios from "axios";
-import { isMap } from "yaml";
+import { isMap, isScalar } from "yaml";
 import * as v from "valibot";
 import prettyMs from "pretty-ms";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
-import { Config, configSchema } from "./ase-config.js";
+import { Config, configSchema, parseScope } from "./ase-config.js";
 import { renderDiagram } from "./ase-diagram.js";
+import { taskLoad, taskSave, taskDelete, taskList } from "./ase-task.js";
 import pkg from "../package.json" with { type: "json" };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
 const PORT_ENV = "ASE_SERVICE_PORT";
@@ -260,6 +261,198 @@ export default class ServiceCommand {
                     };
                 }
             });
+            mcp.registerTool("task_list", {
+                title: "ASE task list",
+                description: "List all persisted task `id`s. " +
+                    "Returns the ids as `text`, one per line, in lexicographic order; " +
+                    "returns an empty string if no tasks exist.",
+                inputSchema: {}
+            }, async () => {
+                try {
+                    const ids = taskList();
+                    return {
+                        content: [{ type: "text", text: ids.join("\n") }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `task_list: ERROR: ${message}` }]
+                    };
+                }
+            });
+            mcp.registerTool("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`.",
+                inputSchema: {
+                    id: z.string()
+                        .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                }
+            }, async (args) => {
+                try {
+                    const text = taskLoad(args.id);
+                    return {
+                        content: [{ type: "text", text }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `task_load: ERROR: ${message}` }]
+                    };
+                }
+            });
+            mcp.registerTool("task_save", {
+                title: "ASE task save",
+                description: "Persist a task as `text` under `id`. " +
+                    "Overwrites any existing task for the same `id`.",
+                inputSchema: {
+                    id: z.string()
+                        .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')"),
+                    text: z.string()
+                        .describe("text content of the task")
+                }
+            }, async (args) => {
+                try {
+                    taskSave(args.id, args.text);
+                    return {
+                        content: [{ type: "text", text: `task_save: OK: saved task "${args.id}"` }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `task_save: FAILED: ${message}` }]
+                    };
+                }
+            });
+            mcp.registerTool("task_delete", {
+                title: "ASE task delete",
+                description: "Delete a previously persisted task by `id`. " +
+                    "Returns a status `text` indicating whether a task existed and was removed.",
+                inputSchema: {
+                    id: z.string()
+                        .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                }
+            }, async (args) => {
+                try {
+                    const removed = taskDelete(args.id);
+                    const msg = removed ?
+                        `task_delete: OK: removed task "${args.id}"` :
+                        `task_delete: WARNING: no task "${args.id}" to remove`;
+                    return {
+                        content: [{ type: "text", text: msg }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `task_delete: ERROR: ${message}` }]
+                    };
+                }
+            });
+            mcp.registerTool("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 broadest scope (user/project cascade). " +
+                    "Allowed styles: \"writer\" (decorative, eloquent, explaining), " +
+                    "\"engineer\" (brief, factual, accurate), " +
+                    "\"telegrapher\" (very brief, factual, abbreviating), " +
+                    "\"caveman\" (ultra brief, rough, stuttering).",
+                inputSchema: {
+                    style: z.enum(["writer", "engineer", "telegrapher", "caveman"]).optional()
+                        .describe("persona style to set; if omitted, the current persona style is returned"),
+                    session: z.string().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 {
+                    const scope = args.session !== undefined ?
+                        parseScope(`session:${args.session}`) :
+                        parseScope(undefined);
+                    const cfg = new Config("config", configSchema, this.log, scope);
+                    cfg.read();
+                    if (args.style !== undefined) {
+                        cfg.set("agent.persona", args.style);
+                        cfg.write();
+                        const where = args.session !== undefined ?
+                            ` for session "${args.session}"` : "";
+                        const msg = `persona: OK: set agent.persona to "${args.style}"${where}`;
+                        return {
+                            content: [{ type: "text", text: msg }]
+                        };
+                    }
+                    const val = cfg.get("agent.persona");
+                    if (val === undefined)
+                        return {
+                            content: [{ type: "text", text: "" }]
+                        };
+                    const text = String(isScalar(val) ? val.value : val);
+                    return {
+                        content: [{ type: "text", text }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `persona: ERROR: ${message}` }]
+                    };
+                }
+            });
+            mcp.registerTool("task_id", {
+                title: "ASE task id get/set",
+                description: "Get or set the active ASE task `id` for a given `session`. " +
+                    "If `id` is provided, it set the task id in the given `session`, " +
+                    "otherwise it returns the current task `id` of the `session`.",
+                inputSchema: {
+                    id: z.string().optional()
+                        .describe("task identifier to set (allowed characters: A-Z, a-z, 0-9, '-'); " +
+                        "if omitted, the current task id is returned"),
+                    session: z.string()
+                        .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                }
+            }, async (args) => {
+                try {
+                    const scope = parseScope(`session:${args.session}`);
+                    const cfg = new Config("config", configSchema, this.log, scope);
+                    cfg.read();
+                    if (args.id !== undefined) {
+                        cfg.set("agent.task", args.id);
+                        cfg.write();
+                        const msg = `task_id: OK: set agent.task to "${args.id}" ` +
+                            `for session "${args.session}"`;
+                        return {
+                            content: [{ type: "text", text: msg }]
+                        };
+                    }
+                    const val = cfg.get("agent.task");
+                    if (val === undefined)
+                        return {
+                            content: [{ type: "text", text: "" }]
+                        };
+                    const text = String(isScalar(val) ? val.value : val);
+                    return {
+                        content: [{ type: "text", text }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `task_id: ERROR: ${message}` }]
+                    };
+                }
+            });
             return mcp;
         };
         /*  listen to HTTP/REST endpoints  */

package/dst/ase-setup.js

@@ -21,9 +21,14 @@ export default class SetupCommand {
         });
     }
     /*  run a sub-process, suppressing output on success and emitting it on failure  */
-    async run(cmd, args, cwd) {
+    async run(cmd, args, opts = {}) {
+        const { cwd, quiet = false } = opts;
         this.log.write("info", `setup: $ ${cmd} ${args.join(" ")}` +
             (cwd !== undefined ? ` (cwd: ${cwd})` : ""));
+        if (quiet) {
+            await execa(cmd, args, { stdio: "ignore", cwd, reject: false });
+            return;
+        }
         await execa(cmd, args, { stdio: "pipe", cwd }).catch((err) => {
             const exitCode = typeof err?.exitCode === "number" ? err.exitCode : -1;
             this.log.write("error", `setup: command failed: exit code: ${exitCode}`);
@@ -53,12 +58,16 @@ export default class SetupCommand {
     async doUpdate(force, dev) {
         await this.ensureTool("npm");
         await this.ensureTool("claude");
+        /*  best-effort stop of background service  */
+        this.log.write("info", `setup: update${dev ? "[dev]" : ""}: ` +
+            "stopping potentially running ASE service");
+        await this.run("ase", ["service", "stop"], { quiet: true });
         if (dev) {
             /*  update ASE CLI Tool  */
             this.log.write("info", "setup: update[dev]: re-build ASE CLI tool (origin: local)");
             const tooldir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-            await this.run("npm", ["install"], tooldir);
-            await this.run("npm", ["start", "build"], tooldir);
+            await this.run("npm", ["install"], { cwd: tooldir });
+            await this.run("npm", ["start", "build"], { cwd: tooldir });
             /*  in development mode the local plugin files are already current
                 but there is no version change in the plugin manifest,
                 so just re-install the plugin to let Claude Code update its copy  */
@@ -88,6 +97,10 @@ export default class SetupCommand {
     async doUninstall(dev) {
         await this.ensureTool("npm");
         await this.ensureTool("claude");
+        /*  best-effort stop of background service  */
+        this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
+            "stopping potentially running ASE service");
+        await this.run("ase", ["service", "stop"], { quiet: true });
         /*  uninstall ASE Claude Code plugin  */
         this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
             `uninstalling ASE Claude Code plugin (origin: ${dev ? "local" : "remote"})`);

package/dst/ase-statusline.js

@@ -0,0 +1,134 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { execaSync } from "execa";
+import { Config, configSchema, parseScope } from "./ase-config.js";
+/*  read stdin into a single string  */
+const readStdin = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    return Buffer.concat(chunks).toString("utf8");
+};
+/*  detect terminal column width via /dev/tty (stdout is a pipe under Claude Code)  */
+const detectTermWidth = () => {
+    let width = 0;
+    try {
+        const tty = fs.openSync("/dev/tty", "r");
+        const out = execFileSync("tput", ["cols"], { stdio: [tty, "pipe", "ignore"] });
+        fs.closeSync(tty);
+        width = parseInt(out.toString("utf8").trim()) || 0;
+    }
+    catch (_e) {
+        /*  no controlling terminal  */
+    }
+    return width;
+};
+/*  command-line handling  */
+export default class StatuslineCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("statusline")
+            .description("Render Claude Code statusline from stdin JSON")
+            .action(async () => {
+            /*  read all of stdin  */
+            const input = await readStdin();
+            /*  parse JSON data  */
+            let data;
+            try {
+                data = JSON.parse(input);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.write("error", `statusline: invalid JSON on stdin: ${message}`);
+                process.exit(1);
+            }
+            /*  fetch information from data  */
+            const dir = path.basename(data.workspace?.current_dir ?? "");
+            const model = data.model?.display_name ?? "";
+            const pct = Math.floor(data.context_window?.used_percentage ?? 0);
+            const effort = data.effort?.level ?? "unknown";
+            const thinking = (data.thinking?.enabled ?? false) === true ? "yes" : "no";
+            const sessionId = data.session_id ?? "unknown";
+            /*  optionally determine ASE task id and persona style via in-process Config  */
+            let taskId = process.env.ASE_TASK_ID ?? "";
+            let persona = process.env.ASE_PERSONA_STYLE ?? "";
+            try {
+                const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
+                cfg.read("lenient");
+                const t = String(cfg.get("agent.task") ?? "").trim();
+                const p = String(cfg.get("agent.persona") ?? "").trim();
+                if (t !== "")
+                    taskId = t;
+                if (p !== "")
+                    persona = p;
+            }
+            catch (_e) {
+                /*  cascade unavailable; keep env-var fallbacks  */
+            }
+            /*  optionally determine terminal width  */
+            const width = detectTermWidth();
+            /*  configure ANSI sequences  */
+            const RESET = "\x1b[0m";
+            const BOLD = "\x1b[1m";
+            const BLACK = "\x1b[30m";
+            const BLUE = "\x1b[34m";
+            const YELLOW = "\x1b[33m";
+            const RED = "\x1b[31m";
+            /*  determine context bar information  */
+            const barSize = 20;
+            const barColor = pct >= 80 ? RED : pct >= 60 ? YELLOW : pct >= 40 ? BLUE : RESET;
+            const filled = Math.round(pct / 100 * barSize);
+            const bar = "█".repeat(filled) + "░".repeat(barSize - filled);
+            /*  generate output  */
+            let output = "";
+            output += `${BLUE}※ user: ${BOLD}${process.env.USER ?? process.env.LOGNAME ?? "unknown"}${RESET} `;
+            if (width > 0 && width < 30)
+                output += "\n";
+            output += `${RED}⚑ project: ${BOLD}${dir}${RESET} `;
+            if (width > 0 && width < 60)
+                output += "\n";
+            if (taskId !== "") {
+                output += `${BLACK}◉ task: ${BOLD}${taskId}${RESET} `;
+                if (width > 0 && width < 90)
+                    output += "\n";
+            }
+            output += `⏻ session: ${BOLD}${sessionId}${RESET}\n`;
+            output += `⚙ model: ${BOLD}${model}${RESET} `;
+            if (width > 0 && width < 30)
+                output += "\n";
+            output += `⚒ effort: ${BOLD}${effort}${RESET} `;
+            if (width > 0 && width < 60)
+                output += "\n";
+            output += `⚛ thinking: ${BOLD}${thinking}${RESET}\n`;
+            if (persona !== "") {
+                output += `☯ persona: ${BOLD}${persona}${RESET} `;
+                if (width > 0 && width < 30)
+                    output += "\n";
+            }
+            output += `${barColor}◔ context: ${bar} ${pct}%${RESET}\n`;
+            /*  send output  */
+            process.stdout.write(output);
+            /*  optionally publish task id to the calling tmux pane as a per-pane user
+                option, so someone (like claudeX) can pick it up via #{@ase_task_id}  */
+            if (process.env.TMUX !== undefined
+                && process.env.TMUX !== ""
+                && process.env.TMUX_PANE !== undefined
+                && process.env.TMUX_PANE !== "") {
+                const tid = taskId !== "" ? taskId : "default";
+                execaSync("tmux", ["set-option", "-p", "-t", process.env.TMUX_PANE,
+                    "@ase_task_id", tid], { stdio: "ignore", reject: false });
+            }
+        });
+    }
+}

package/dst/ase-task.js

@@ -0,0 +1,195 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { execaSync } from "execa";
+/*  validate the task id to keep it safe as a filename component  */
+const validateId = (id) => {
+    if (typeof id !== "string" || id.length === 0)
+        throw new Error("task: id must be a non-empty string");
+    if (!/^[A-Za-z0-9-]+$/.test(id))
+        throw new Error("task: id must match [A-Za-z0-9-]+");
+};
+/*  resolve the on-disk path for a given task id  */
+const taskPath = (id) => {
+    validateId(id);
+    return path.join(os.homedir(), ".ase", "task", id, "plan.md");
+};
+/*  load a task; returns empty string if no task exists  */
+export const taskLoad = (id) => {
+    const file = taskPath(id);
+    if (!fs.existsSync(file))
+        return "";
+    return fs.readFileSync(file, "utf8");
+};
+/*  save a task as UTF-8 text under the given id; the task's home
+    directory ~/.ase/task/<id>/ is owned by ASE and removed in full
+    by taskDelete, so callers must not place foreign files there  */
+export const taskSave = (id, text) => {
+    if (typeof text !== "string")
+        throw new Error("task: text must be a string");
+    const file = taskPath(id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text, "utf8");
+};
+/*  delete a task by id; removes the entire task home directory
+    ~/.ase/task/<id>/ (owned by ASE); returns true if a task existed  */
+export const taskDelete = (id) => {
+    const file = taskPath(id);
+    if (!fs.existsSync(file))
+        return false;
+    fs.rmSync(path.dirname(file), { recursive: true, force: true });
+    return true;
+};
+/*  list all persisted task ids in lexicographic order  */
+export const taskList = () => {
+    const dir = path.join(os.homedir(), ".ase", "task");
+    if (!fs.existsSync(dir))
+        return [];
+    const ids = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!/^[A-Za-z0-9-]+$/.test(entry))
+            continue;
+        const file = path.join(dir, entry, "plan.md");
+        if (!fs.existsSync(file))
+            continue;
+        const st = fs.statSync(file);
+        if (!st.isFile())
+            continue;
+        ids.push(entry);
+    }
+    ids.sort();
+    return ids;
+};
+/*  purge tasks whose modification time is older than the given cutoff in
+    milliseconds; returns the list of removed task ids  */
+export const taskPurge = (maxAgeMs) => {
+    const dir = path.join(os.homedir(), ".ase", "task");
+    if (!fs.existsSync(dir))
+        return [];
+    const cutoff = Date.now() - maxAgeMs;
+    const removed = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!/^[A-Za-z0-9-]+$/.test(entry))
+            continue;
+        const sub = path.join(dir, entry);
+        const file = path.join(sub, "plan.md");
+        if (!fs.existsSync(file))
+            continue;
+        const st = fs.statSync(file);
+        if (!st.isFile())
+            continue;
+        if (st.mtimeMs < cutoff) {
+            fs.rmSync(sub, { recursive: true, force: true });
+            removed.push(entry);
+        }
+    }
+    return removed;
+};
+/*  read all of stdin as a UTF-8 string  */
+const readStdin = () => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", (err) => reject(err));
+    });
+};
+/*  CLI command "ase task"  */
+export default class TaskCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register commands  */
+    register(program) {
+        /*  register CLI top-level command "ase task"  */
+        const task = program
+            .command("task")
+            .description("Manage persisted tasks under ~/.ase/task/<id>/plan.md")
+            .action(() => {
+            task.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase task list"  */
+        task
+            .command("list")
+            .description("List all persisted task ids, one per line")
+            .action(() => {
+            const ids = taskList();
+            for (const id of ids)
+                process.stdout.write(`${id}\n`);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase task load"  */
+        task
+            .command("load")
+            .description("Load a task by id and write it to stdout")
+            .argument("<id>", "Task identifier")
+            .action((id) => {
+            const text = taskLoad(id);
+            process.stdout.write(text);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase task edit"  */
+        task
+            .command("edit")
+            .description("Edit a task by id with $EDITOR")
+            .argument("<id>", "Task identifier")
+            .action((id) => {
+            const file = taskPath(id);
+            const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            if (!fs.existsSync(file))
+                fs.writeFileSync(file, "", "utf8");
+            execaSync(editor, [file], { stdio: "inherit" });
+            this.log.write("info", `task: edited "${id}"`);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase task save"  */
+        task
+            .command("save")
+            .description("Save a task by id, reading content from stdin")
+            .argument("<id>", "Task identifier")
+            .action(async (id) => {
+            const text = await readStdin();
+            taskSave(id, text);
+            this.log.write("info", `task: saved "${id}"`);
+            process.exit(0);
+        });
+        /*  register CLI sub-command "ase task delete"  */
+        task
+            .command("delete")
+            .description("Delete a task by id")
+            .argument("<id>", "Task identifier")
+            .action((id) => {
+            const removed = taskDelete(id);
+            if (removed)
+                this.log.write("info", `task: removed "${id}"`);
+            else
+                this.log.write("info", `task: no task "${id}" to remove`);
+            process.exit(removed ? 0 : 1);
+        });
+        /*  register CLI sub-command "ase task purge"  */
+        task
+            .command("purge")
+            .description("Remove all tasks with a modification time older than <days> (default: 31)")
+            .argument("[<days>]", "Maximum task age in days", "31")
+            .action((days) => {
+            const n = Number.parseInt(days, 10);
+            if (!Number.isFinite(n) || n < 0)
+                throw new Error("task: <days> must be a non-negative integer");
+            const removed = taskPurge(n * 24 * 60 * 60 * 1000);
+            if (removed.length === 0)
+                this.log.write("info", "task: no tasks to purge");
+            else
+                for (const id of removed)
+                    this.log.write("info", `task: purged "${id}"`);
+            process.exit(0);
+        });
+    }
+}

package/dst/ase.js

@@ -12,6 +12,8 @@ import MCPCommand from "./ase-mcp.js";
 import HookCommand from "./ase-hook.js";
 import DiagramCommand from "./ase-diagram.js";
 import SetupCommand from "./ase-setup.js";
+import StatuslineCommand from "./ase-statusline.js";
+import TaskCommand from "./ase-task.js";
 import pkg from "../package.json" with { type: "json" };
 /*  globally initialize logger  */
 const log = new Log("ase", "warning", "-");
@@ -46,6 +48,8 @@ const main = async () => {
     new HookCommand(log).register(program);
     new DiagramCommand(log).register(program);
     new SetupCommand(log).register(program);
+    new StatuslineCommand(log).register(program);
+    new TaskCommand(log).register(program);
     /*  parse program arguments  */
     await program.parseAsync(process.argv);
     /*  gracefully terminate  */

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.0.17",
+    "version":                              "0.0.19",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",