@rse/ase 2.0.6 → 2.0.8

package/dst/ase-agent-definition-api.d.ts

@@ -18,6 +18,7 @@ export interface AgentDefinition {
     lifecycle?: Many<string>;
     serial?: boolean;
     unclaimed?: boolean;
+    model?: string;
     state?: {
         incoming?: Many<string>;
         activity?: string;
@@ -175,6 +176,7 @@ export interface AgentHooks {
     ready?: (task: AgentHookTask, ctx: AgentHookContext) => Async<boolean | string>;
     prepare?: (task: AgentHookTask, job: AgentHookJob, ctx: AgentHookContext) => Async<void>;
     prompt?: (task: AgentHookTask, prompt: AgentHookPrompt, job: AgentHookJob, ctx: AgentHookContext) => Async<AgentHookPrompt | string | undefined>;
+    model?: (task: AgentHookTask, model: string, job: AgentHookJob, ctx: AgentHookContext) => Async<string | undefined>;
     verdict?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<string | undefined>;
     success?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<boolean | string>;
     settle?: (task: AgentHookTask, outcome: AgentHookOutcome, ctx: AgentHookContext) => Async<AgentHookSettlement | undefined>;

package/dst/ase-agent-definition-core.js

@@ -92,6 +92,9 @@ export const definitionOptions = [
     opt("unclaimed", "flag", "", "process the tasks of the incoming states (each adapted onto the " +
         "task lifecycle model) without claiming them, independent of their assignee and predecessors, " +
         "and without ever changing their status and assignee (for \"phase\" only)"),
+    opt("model", "value", "model", "model of the agent tool: a model for all tasks, or comma-separated " +
+        "\"<size>=<model>\" pairs per \"Effort:\" size (\"XS\", \"S\", \"M\", \"L\", \"XL\", or \"*\" for all other tasks) " +
+        "(default: the default model of the agent tool)"),
     opt("params", "list", "name=value", "value of a parameter declared by the definition (repeatable)"),
     opt("state-incoming", "list", "state", "state of the tasks to claim (mandatory for \"phase\", " +
         "repeatable with \"--unclaimed\" or \"--state-activity\" only)"),
@@ -272,7 +275,7 @@ export const flattenDefinition = (data, where) => {
     return flat;
 };
 /*  the names of the hooks of a definition (see "AgentHooks")  */
-const hookNames = ["start", "order", "passes", "ready", "prepare", "prompt", "verdict", "success", "settle", "finish", "stop"];
+const hookNames = ["start", "order", "passes", "ready", "prepare", "prompt", "model", "verdict", "success", "settle", "finish", "stop"];
 /*  normalize the parameter declarations <spec> of a definition (see "AgentParam"),
     where <where> names the definition in errors  */
 const definitionParams = (spec, where) => {
@@ -741,6 +744,24 @@ export const resolveDefinition = async (opts, name) => {
         if (loaded.hooks.passes !== undefined)
             fail("definition", "hook \"passes\" is not for \"--unclaimed\" (as an unclaimed task never waits for its predecessors)");
     }
+    /*  the model of the agent tool: a plain model (for all tasks, as size "*"),
+        or the models per "Effort:" size, where none means the default of the tool  */
+    const modelSpec = str("model").trim();
+    const sizes = {};
+    if (modelSpec !== "" && !modelSpec.includes("="))
+        sizes["*"] = modelSpec;
+    else if (modelSpec !== "") {
+        for (const pair of modelSpec.split(",").map((item) => item.trim())) {
+            const m = /^(XS|S|M|L|XL|\*)=(\S+)$/.exec(pair);
+            if (m === null)
+                fail("model", `invalid pair "${pair}" (expected "<size>=<model>" with size "XS", "S", "M", "L", "XL", or "*")`);
+            else if (Object.hasOwn(sizes, m[1]))
+                fail("model", `size "${m[1]}" given twice`);
+            else
+                sizes[m[1]] = m[2];
+        }
+    }
+    const model = { spec: modelSpec, sizes };
     /*  whether a verdict is determined (by "--verdict-label" or the hook "verdict")  */
     const verdicting = has("verdict-label") || loaded.hooks.verdict !== undefined;
     /*  the states (see "resolveStates")  */
@@ -821,10 +842,10 @@ export const resolveDefinition = async (opts, name) => {
         hence the prompt of the request), resp. uses them optionally by "{prompt}" used only
         within the conditional "{?prompt:...}", else ignores them  */
     const consumes = type === "request" && (template.required.has("prompt")
-        || ["prepare", "prompt", "finish"].some((hook) => loaded.hooks[hook] !== undefined)) ? "required" :
+        || ["prepare", "prompt", "model", "finish"].some((hook) => loaded.hooks[hook] !== undefined)) ? "required" :
         type === "request" && template.names.has("prompt") ? "optional" : "ignored";
     return {
-        name, title, description, type, workdir, lifecycles, unclaimed,
+        name, title, description, type, workdir, lifecycles, unclaimed, model,
         serial: flag("serial"),
         state: { incoming, activity, success, failure, phase, passed, verdict: verdicts },
         tag: {

package/dst/ase-agent-fleet.js

@@ -45,7 +45,7 @@ const logLevelRe = /^([^|]*\| [^:]+: \[[^\]]+\]: )\[(ERROR|WARNING|INFO|DEBUG)\]
     agents, and applied to an agent only if it supports them)  */
 const fleetKeys = ["foreground"];
 const relayKeys = ["address", "port", "token", "cors", "tls-cert", "tls-key"];
-const defaultKeys = ["tool", "parallel", "timeout", "repo", "tempdir", "agent-relay"];
+const defaultKeys = ["tool", "model", "parallel", "timeout", "repo", "tempdir", "agent-relay"];
 /*  the options not allowed in the section of an agent, as the fleet decides on them  */
 const deniedKeys = ["name", "one-shot", "foreground", "help"];
 /*  the state of the planned tasks per task lifecycle model, as estimated by the estimator  */
@@ -76,6 +76,7 @@ const initConfig = (tool, lifecycle) => [
     #   (each applied only to the agents supporting it, where an empty value omits it)
     default:
         tool:           ${tool.padEnd(16)}# agent tool ("claude", "copilot", or "codex")
+        #model:         <model>         # model of the agent tool (or "<size>=<model>" pairs per "Effort:" size)
         parallel:       1               # maximum number of tasks processed in parallel
         timeout:        60m             # maximum duration of processing a task (<number><unit> with unit "s", "m", or "h")
         #repo:          <url>           # Git repository to clone temporarily for the tasks without "worktree"

package/dst/ase-agent-relay-client.js

@@ -4,8 +4,6 @@
 **  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
 */
 import os from "node:os";
-import { ofetch } from "ofetch";
-import { Agent } from "undici";
 import * as v from "valibot";
 import { WebSocket } from "ws";
 import { isScalar } from "yaml";
@@ -14,6 +12,7 @@ import { configSchema } from "./ase-config-schema.js";
 import { parseScope } from "./ase-config-scope.js";
 import * as TaskFormat from "./ase-task-format.js";
 import { urlHost, isLoopback } from "./ase-lib-server-bind.js";
+import { dispatchFetch, insecureAgent } from "./ase-lib-fetch.js";
 import { storeSchema } from "./ase-task-store-server-cli.js";
 import { relaySchema } from "./ase-agent-relay-server-cli.js";
 import * as Relay from "./ase-agent-relay-core.js";
@@ -181,7 +180,7 @@ export class AgentRelayClient {
     constructor(log, spec) {
         this.log = log;
         this.spec = spec;
-        this.dispatcher = spec.insecure ? new Agent({ connect: { rejectUnauthorized: false } }) : undefined;
+        this.dispatcher = spec.insecure ? insecureAgent() : undefined;
     }
     /*  the base URL of the agent relay  */
     get base() {
@@ -189,7 +188,7 @@ export class AgentRelayClient {
     }
     /*  perform a request, raising an error response or a failed connection  */
     async request(method, url, body) {
-        const r = await ofetch.raw(`${this.spec.base}/projects/${this.spec.prjId}/agents${url}`, {
+        const r = await dispatchFetch.raw(`${this.spec.base}/projects/${this.spec.prjId}/agents${url}`, {
             method,
             headers: {
                 Authorization: `Bearer ${this.spec.token}`,

package/dst/ase-agent-runtime-engine.js

@@ -45,6 +45,15 @@ const promptOf = (value, configured) => {
     }
     throw new Error("invalid prompt (expected a string, \"{ text }\", or \"{ skill, args }\")");
 };
+/*  the model returned by the hook "model", validated, where undefined
+    keeps the configured model <configured>  */
+const modelOf = (value, configured) => {
+    if (value === undefined)
+        return configured;
+    else if (typeof value !== "string")
+        throw new Error("invalid model (expected a string)");
+    return value.trim();
+};
 /*  whether a record of an agent of a definition succeeded (where a missing one counts as failure)  */
 const recordSuccess = (record) => record !== undefined && record.fixed === "" && record.checks.every((check) => check.ok);
 /*  escape a text for its literal use in a regular expression  */
@@ -331,7 +340,7 @@ class DefinedCore {
     }
     /*  prepare the job of a task in its work <work>: render the prompt (with the request
         prompt <prompt> of a request agent), run the preparing commands, and run the hooks
-        "prepare" and "prompt", where the work is cleaned up again on a failure, and where
+        "prepare", "prompt", and "model", where the work is cleaned up again on a failure, and where
         <changed> decides preliminarily whether the plan content of a request agent changed  */
     async prepare(task, log, work, prompt, changed) {
         try {
@@ -374,7 +383,7 @@ class DefinedCore {
                     throw err;
                 }
             }
-            /*  run the hooks "prepare" and "prompt", where a failed hook fails the processing  */
+            /*  run the hooks "prepare", "prompt", and "model", where a failed hook fails the processing  */
             const job = Object.freeze({
                 dir: work.cwd,
                 dirs: Object.freeze([...work.dirs]),
@@ -392,7 +401,7 @@ class DefinedCore {
                     throw new Error(`agent: hook "${name}" failed: ${reason(err)}`, { cause: err });
                 }
             };
-            const { prepare: prepareHook, prompt: promptHook } = this.def.hooks;
+            const { prepare: prepareHook, prompt: promptHook, model: modelHook } = this.def.hooks;
             if (prepareHook !== undefined)
                 await hooked("prepare", async () => prepareHook(this.task(task), job, ctx));
             let spec = this.def.prompt.skill !== "" ?
@@ -401,10 +410,17 @@ class DefinedCore {
                 const configured = Object.freeze(spec);
                 spec = await hooked("prompt", async () => promptOf(await promptHook(this.task(task), configured, job, ctx), configured));
             }
+            const { sizes } = this.def.model;
+            let model = sizes[TaskFormat.parseEffort(task.keys.get("Effort") ?? "")?.size ?? "*"] ?? sizes["*"] ?? "";
+            if (modelHook !== undefined) {
+                const configured = model;
+                model = await hooked("model", async () => modelOf(await modelHook(this.task(task), configured, job, ctx), configured));
+            }
             return {
                 ...("skill" in spec ?
                     { cmd: `${spec.skill}${spec.args !== "" ? ` ${spec.args}` : ""}` } :
                     { prompt: spec.text }),
+                model,
                 cwd: work.cwd,
                 dirs: work.dirs,
                 finish: (log, result) => this.finish(task, log, result, work, job, env, before, changed),
@@ -714,6 +730,7 @@ class DefinedPhaseAgent extends PhaseAgent {
         };
         this.presenceTitle = def.title;
         this.presenceDesc = def.description;
+        this.modelSpec = def.model.spec;
         this.assigned = def.assign.required;
         this.finishing = def.finish.commit || def.finish.success !== "" || def.workdir === "target"
             || def.hooks.finish !== undefined;
@@ -858,6 +875,7 @@ class DefinedRequestAgent extends RequestAgent {
         this.presencePrompt = def.request.prompt;
         this.presenceTitle = def.title;
         this.presenceDesc = def.description;
+        this.modelSpec = def.model.spec;
         this.serial = def.serial;
         this.worktree = def.workdir !== "project";
         this.lifecycles = def.lifecycles;
@@ -950,7 +968,7 @@ export class DefinedAgent extends Agent {
         for (const option of definitionOptions) {
             if (option.key === "definition" && !definition)
                 continue;
-            const flags = (option.key === "definition" ? "-D, " : "") + `--${option.key}` +
+            const flags = (option.key === "definition" ? "-D, " : option.key === "model" ? "-M, " : "") + `--${option.key}` +
                 (option.kind !== "flag" ? ` <${option.arg}>` : "");
             if (option.kind === "list")
                 cmd.option(flags, option.desc, (value, prev) => [...(prev ?? []), value]);

package/dst/ase-agent-runtime-tool.js

@@ -8,20 +8,22 @@ import { stripVTControlCharacters } from "node:util";
     of the task (as an agent message can be huge, e.g. the rendering of the whole task plan,
     which would otherwise be fed back into the next rendering of the task plan)  */
 const TEXT_MAX = 20;
+/*  the "--model" option of all tools for the model <model> (none for the default model)  */
+const modelArgs = (model) => model !== "" ? ["--model", model] : [];
 /*  the per-tool headless invocation of the rendered prompt <prompt> with access to the
-    additional directories <add> (the "--add-dir" options), streaming JSONL events,
-    where risky actions are denied or automatically reviewed instead of being prompted for
+    additional directories <add> (the "--add-dir" options) and the model <model>, streaming JSONL
+    events, where risky actions are denied or automatically reviewed instead of being prompted for
     (the variadic "--add-dir" of Claude has to precede the other options to not consume the prompt)  */
 export const toolArgs = {
-    "claude": (prompt, add) => [
-        ...add, "-p", "--output-format", "stream-json", "--verbose", "--disallowedTools", "AskUserQuestion",
+    "claude": (prompt, add, model) => [
+        ...add, ...modelArgs(model), "-p", "--output-format", "stream-json", "--verbose", "--disallowedTools", "AskUserQuestion",
         "--permission-mode", "auto", "--permission-prompts", "none", prompt
     ],
-    "copilot": (prompt, add) => [
-        ...add, "--allow-all-tools", "--no-ask-user", "--no-color", "--output-format", "json", "-p", prompt
+    "copilot": (prompt, add, model) => [
+        ...add, ...modelArgs(model), "--allow-all-tools", "--no-ask-user", "--no-color", "--output-format", "json", "-p", prompt
     ],
-    "codex": (prompt, add) => [
-        "exec", ...add, "--json", "--approve-for-me", "--color", "never", prompt
+    "codex": (prompt, add, model) => [
+        "exec", ...add, ...modelArgs(model), "--json", "--approve-for-me", "--color", "never", prompt
     ]
 };
 /*  the per-tool rendering of the invocation of the skill <skill> with the arguments <args>:

package/dst/ase-agent-runtime.js

@@ -145,6 +145,8 @@ export class Agent {
     /*  the title and the description of the operation of the agent, as announced in its presence (default: none)  */
     presenceTitle = "";
     presenceDesc = "";
+    /*  the configured model of the agent tool, as shown in the start log line (default: none)  */
+    modelSpec = "";
     /*  whether tasks are processed serially only (clamping "--parallel" to 1, and
         refusing multiple agents of the kind in a fleet, see "ase agent fleet")  */
     serial = false;
@@ -840,7 +842,8 @@ export class Agent {
         const cli = toolSpecs[tool].cli;
         const cmd = job.cmd ?? "";
         const i = cmd.indexOf(" ");
-        const args = toolArgs[tool](job.prompt ?? skillPrompt(tool, i < 0 ? cmd : cmd.slice(0, i), i < 0 ? "" : cmd.slice(i + 1)), [...new Set(job.dirs ?? [])].filter((dir) => dir !== cwd).flatMap((dir) => ["--add-dir", dir]));
+        const model = job.model ?? "";
+        const args = toolArgs[tool](job.prompt ?? skillPrompt(tool, i < 0 ? cmd : cmd.slice(0, i), i < 0 ? "" : cmd.slice(i + 1)), [...new Set(job.dirs ?? [])].filter((dir) => dir !== cwd).flatMap((dir) => ["--add-dir", dir]), model);
         await log("info", `running: ${cli} ${args.map((arg) => arg.includes(" ") ? `"${arg}"` : arg).join(" ")}`);
         const started = Date.now();
         const costs = { costToken: null, costUSD: null, cread: 0, cwrite: 0, input: 0, apiMs: null };
@@ -881,7 +884,7 @@ export class Agent {
         this.presence?.used(usage);
         /*  book the usage onto the task, if the AI usage accounting is enabled ("telemetry.enabled"),
             (the AI request time falling back to the wall time and an unreported cost to the price
-            table entry of the tool, as its model is unknown), without any human time and costs,
+            table entry of the given model, else of the tool), without any human time and costs,
             as the headless agent tool runs unattended; the times are booked in rounded minutes,
             with the (signed) rounding remainder carried over to the next booking onto the task,
             where a failed booking is only reported  */
@@ -894,7 +897,8 @@ export class Agent {
             if (cost === null) {
                 const cfg = new Config("config", configSchema, this.log);
                 cfg.read();
-                cost = tokenCost(modelPrice(parsePrices(String(cfg.get("telemetry.prices.ai") ?? "")), tool), tokens);
+                const prices = parsePrices(String(cfg.get("telemetry.prices.ai") ?? ""));
+                cost = tokenCost(modelPrice(prices, model !== "" && prices.has(model) ? model : tool), tokens);
             }
             const carry = this.unbooked.get(taskId) ?? { aiMs: 0, realMs: 0 };
             const aiMs = carry.aiMs + (costs.apiMs ?? walltimeMs);
@@ -1250,7 +1254,7 @@ export class Agent {
             if (this.repo !== "")
                 await this.cloneRepo();
             await this.write("info", this.name, `observing ${this.observing()} ` +
-                `(tool: ${tool}, parallel: ${parallel}, timeout: ${this.timeoutSpec}${this.oneShot ? ", one-shot" : ""})`);
+                `(tool: ${tool}${this.modelSpec !== "" ? `, model: ${this.modelSpec}` : ""}, parallel: ${parallel}, timeout: ${this.timeoutSpec}${this.oneShot ? ", one-shot" : ""})`);
             let finished = false;
             let failure = null;
             while (!abort.signal.aborted && !finished) {

package/dst/ase-config-schema.js

@@ -78,6 +78,7 @@ export const projectClassificationPresets = {
         "board.web.color.accent": webColorDefaults.accent,
         "board.web.color.signal": webColorDefaults.signal,
         "board.web.editor.keymap": "default",
+        "board.web.theme": "auto",
         "telemetry.enabled": "false",
         "telemetry.implicit": "true",
         "telemetry.prices.ai": "*=4.00/20.00/0.20/5.00",
@@ -131,6 +132,7 @@ export const configWritableScopes = {
     "board.web.color.accent": ["user", "project"],
     "board.web.color.signal": ["user", "project"],
     "board.web.editor.keymap": ["user", "project"],
+    "board.web.theme": ["user", "project"],
     "telemetry.enabled": ["user", "project"],
     "telemetry.implicit": ["user", "project"],
     "telemetry.service.port": ["user"],
@@ -337,7 +339,8 @@ export const configSchema = v.nullish(v.strictObject({
             })),
             editor: v.optional(v.strictObject({
                 keymap: v.optional(v.picklist(["default", "vim", "emacs"]))
-            }))
+            })),
+            theme: v.optional(v.picklist(["auto", "light", "dark"]))
         }))
     }))
 }));

package/dst/ase-lib-fetch.js

@@ -0,0 +1,12 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import { ofetch } from "ofetch";
+import { Agent, fetch as undiciFetch } from "undici";
+/*  the fetch for requests with a dispatcher of the npm "undici": its own fetch, as the
+    built-in fetch of Node (its bundled, possibly older undici) rejects a foreign dispatcher  */
+export const dispatchFetch = ofetch.create({}, { fetch: undiciFetch });
+/*  create a dispatcher skipping the TLS certificate verification  */
+export const insecureAgent = () => new Agent({ connect: { rejectUnauthorized: false } });

package/dst/ase-lib-server-cli.js

@@ -7,20 +7,19 @@ import path from "node:path";
 import fs from "node:fs";
 import crypto from "node:crypto";
 import os from "node:os";
-import { ofetch } from "ofetch";
-import { Agent } from "undici";
 import { isSeq, isScalar } from "yaml";
 import { Config } from "./ase-config-core.js";
 import { parseScope } from "./ase-config-scope.js";
 import { isLogLevel } from "./ase-lib-log.js";
 import { writeStdout } from "./ase-lib-stdio.js";
+import { dispatchFetch, insecureAgent } from "./ase-lib-fetch.js";
 import { Daemon, DaemonCommand } from "./ase-lib-daemon-cli.js";
 import { urlHost, isLoopback, serverHeader } from "./ase-lib-server-bind.js";
 /*  the defaults  */
 export const DEFAULT_ADDRESS = "127.0.0.1";
 /*  the dispatcher of the host-local probe, skipping the certificate verification,
     as a certificate rarely covers a loopback or local interface address  */
-const probeAgent = new Agent({ connect: { rejectUnauthorized: false } });
+const probeAgent = insecureAgent();
 /*  whether an address belongs to this host (loopback or a local network interface)  */
 export const isLocal = (address) => isLoopback(address) || Object.values(os.networkInterfaces())
     .some((ifaces) => (ifaces ?? []).some((iface) => iface.address === address));
@@ -146,7 +145,7 @@ export class ServerCommand extends DaemonCommand {
         /*  skip the certificate verification for host-local addresses only,
             as elsewhere a man-in-the-middle could capture the token  */
         const lax = isLocal(host.replace(/^\[|\]$/g, ""));
-        const request = (auth) => ofetch.raw(url, {
+        const request = (auth) => dispatchFetch.raw(url, {
             method: "GET",
             headers: auth !== null ? { Authorization: `Bearer ${auth}` } : {},
             dispatcher: lax ? probeAgent : undefined,
@@ -170,8 +169,12 @@ export class ServerCommand extends DaemonCommand {
                 return "running";
             return "foreign";
         }
-        catch {
+        catch (err) {
             /*  treat an unreachable or unresponsive server as not running  */
+            let cause = err;
+            while (cause instanceof Error && cause.cause instanceof Error)
+                cause = cause.cause;
+            this.log.write("debug", `${this.label}: probe of ${url} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
             return null;
         }
     }

package/dst/ase-man-catalog.js

@@ -24,7 +24,7 @@ const skillGroups = [
     ["SPEC", ["ase-spec-lint", "ase-spec-edit", "ase-spec-activate"]],
     ["CODE", ["ase-code-edit", "ase-code-analyze", "ase-code-insight", "ase-code-explain", "ase-code-lint"]],
     ["REPO", ["ase-repo-review", "ase-repo-diff", "ase-repo-changelog", "ase-repo-commit",
-            "ase-repo-dissect", "ase-repo-merge", "ase-repo-resolve"]],
+            "ase-repo-dissect", "ase-repo-stage", "ase-repo-merge", "ase-repo-resolve"]],
     ["SYNC", ["ase-sync-reconcile", "ase-sync-import", "ase-sync-export"]],
     ["TASK: MANAGE", ["ase-task-list", "ase-task-rename", "ase-task-delete"]],
     ["TASK: HANDLE", ["ase-task-id", "ase-task-status", "ase-task-assign"]],

package/dst/ase-task-board-diff.js

@@ -0,0 +1,120 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import { diffArrays } from "diff";
+/*  the changed share of the words up to which they are emphasized, the Markdown
+    syntax characters never being emphasized (as this would break their constructs),
+    the closing placeholder of a change mark, and the leading syntax of a Markdown
+    line (block quote, heading, or list marker) and its checkbox, staying outside of
+    its mark resp. of its emphasized words  */
+const ALIKE = 0.4;
+const SYNTAX = /^[*`~|\\[\]()<>#!]$/;
+const CLOSE = "⟦/chg⟧";
+const HEAD = /^\s*(?:>\s*)*(?:#{1,6}[ \t]+|(?:[-*+]|\d+[.)])[ \t]+)?/;
+const BOX = /^\[.\][ \t]+/;
+/*  split two lists of items, compared by their keys, into the parts of their diff  */
+export const diffHunks = (before, after, key) => {
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    for (const { added, removed, count } of diffArrays(before.map(key), after.map(key))) {
+        if (!added && !removed) {
+            hunks.push({ kept: after.slice(j, j + count), removed: [], added: [] });
+            i += count;
+            j += count;
+            continue;
+        }
+        let hunk = hunks.at(-1);
+        if (hunk === undefined || hunk.kept.length > 0) {
+            hunk = { kept: [], removed: [], added: [] };
+            hunks.push(hunk);
+        }
+        if (removed) {
+            hunk.removed.push(...before.slice(i, i + count));
+            i += count;
+        }
+        else {
+            hunk.added.push(...after.slice(j, j + count));
+            j += count;
+        }
+    }
+    return hunks;
+};
+const tokens = (lines) => lines.flatMap((line, row) => [...line.matchAll(/[\p{L}\p{N}_]+|\S/gu)].map((m) => ({ text: m[0], row, from: m.index, to: m.index + m[0].length })));
+/*  determine the changed words of the removed and added lines of a change (joined with
+    the blanks between adjacent ones), unless too many of the words changed, where the
+    words alone decide, so a change of the wrapping only emphasizes nothing  */
+export const changedWords = (removed, added) => {
+    const a = tokens(removed);
+    const b = tokens(added);
+    const del = removed.map(() => []);
+    const add = added.map(() => []);
+    const changes = diffArrays(a.map((token) => token.text), b.map((token) => token.text));
+    const changed = changes.reduce((n, change) => n + (change.added || change.removed ? change.count : 0), 0);
+    if (changed > (a.length + b.length) * ALIKE)
+        return [del, add];
+    const mark = (list, spans) => {
+        let last;
+        for (const token of list) {
+            const row = spans[token.row];
+            if (SYNTAX.test(token.text))
+                last = undefined;
+            else {
+                if (last?.row === token.row)
+                    row[row.length - 1].to = token.to;
+                else
+                    row.push({ from: token.from, to: token.to });
+                last = token;
+            }
+        }
+    };
+    let i = 0;
+    let j = 0;
+    for (const { added: plus, removed: minus, count } of changes) {
+        if (minus)
+            mark(a.slice(i, i + count), del);
+        else if (plus)
+            mark(b.slice(j, j + count), add);
+        i += plus ? 0 : count;
+        j += minus ? 0 : count;
+    }
+    return [del, add];
+};
+/*  mark a changed Markdown line and its changed words through placeholders surviving
+    the Markdown rendering: fences and lines of pure syntax stay unmarked (as a
+    mark would break them), and the cells of a table row are marked individually  */
+const markLine = (line, kind, spans) => {
+    if (!/[\p{L}\p{N}]/u.test(line) || /^\s*(?:```|~~~)/.test(line))
+        return line;
+    if (/^\s*\|/.test(line))
+        return line.split(/(?<!\\)\|/).map((cell) => cell.replace(/\S(?:.*\S)?/, (text) => `⟦chg:${kind}⟧${text}${CLOSE}`)).join("|");
+    const head = HEAD.exec(line)[0];
+    const rest = line.slice(head.length);
+    const box = BOX.exec(rest)?.[0] ?? "";
+    let text = rest.slice(box.length);
+    for (const { from, to } of [...spans].reverse())
+        text = `${text.slice(0, from)}⟦chg:${kind}-word⟧${text.slice(from, to)}${CLOSE}${text.slice(to)}`;
+    return `${head}⟦chg:${kind}⟧${box}${text}${CLOSE}`;
+};
+/*  the text of a Markdown line, without its leading syntax and its checkbox  */
+const lineText = (line) => {
+    const rest = line.slice(HEAD.exec(line)[0].length);
+    return rest.slice(BOX.exec(rest)?.[0].length ?? 0);
+};
+/*  merge two Markdown texts into one, with the removed before the added lines of a
+    change and with both marked through placeholders (resolved by "diffMarksToHTML")  */
+export const diffMarkdown = (before, after) => diffHunks(before.split(/\r?\n/), after.split(/\r?\n/), (line) => line).flatMap(({ kept, removed, added }) => {
+    const [del, add] = changedWords(removed.map(lineText), added.map(lineText));
+    return [
+        ...kept,
+        ...removed.map((line, k) => markLine(line, "del", del[k])),
+        ...added.map((line, k) => markLine(line, "add", add[k]))
+    ];
+}).join("\n");
+/*  resolve the placeholders of the change marks in rendered HTML, where
+    the ones which ended up inside a tag (like in a link target) are dropped  */
+export const diffMarksToHTML = (html) => html.replace(/<[^>]*⟦[^>]*>/g, (tag) => tag.replace(/⟦\/?chg[^⟧]*⟧/g, ""))
+    .replace(/⟦chg:([a-z-]+)⟧/g, (_m, kinds) => `<span class="chg ${kinds.replace(/-/g, " ")}">`)
+    .replace(/⟦\/chg⟧/g, "</span>");

package/dst/ase-task-board-tui-control.js

@@ -12,7 +12,7 @@ import { refSegs, tabFirst, tabLayout, confirmBox, transferBox, assignBox, promp
 /*  handle a mouse press onto the deletion confirmation, the transfer popup, the assign
     popup, the prompt popup, or the read dialog, returning whether one of them was open  */
 const handlePopupMouse = (ctx, btn, mx, my) => {
-    const { columns, rows, all, dialog, setDialog, setNotice, confirm, setConfirm, transfer, setTransfer, assign, setAssign, assignTo, prompt, setPrompt, cancelPrompt, submitPrompt, dialogW, tabLabels, dialogSel, dialogScroll, transferList, remove, transferTo } = ctx;
+    const { columns, rows, all, dialog, setDialog, setNotice, confirm, setConfirm, transfer, setTransfer, assign, setAssign, assignTo, prompt, setPrompt, cancelPrompt, submitPrompt, dialogW, tabLabels, dialogSel, dialogScroll, transferList, remove, transferTo, watched } = ctx;
     if (prompt !== null) {
         /*  a click onto a suggested request name of the drop-down picks it (and switches to the
             prompt, resp. to the request button if the prompt is ignored), a click onto the request
@@ -85,10 +85,11 @@ const handlePopupMouse = (ctx, btn, mx, my) => {
         return true;
     }
     if (dialog !== null) {
-        /*  a click onto the " X " of the header (the second dialog row) closes  */
+        /*  a click onto the " X " of the header (the second dialog row) closes
+            (the task viewer has no " X " at all, as only "q" quits it)  */
         const barX = Math.floor((columns - dialogW) / 2) + 1;
         const closeX = barX - 1 + dialogW - DIALOG_CLOSE;
-        if (btn === 0 && my === 1 && mx >= closeX && mx < closeX + 3)
+        if (btn === 0 && my === 1 && mx >= closeX && mx < closeX + 3 && watched === undefined)
             setDialog(null);
         else if (btn === 0 && my === 3 && mx >= barX && mx < barX + dialogW - 2) {
             /*  a click onto a predecessor or successor id (in the fourth dialog row) jumps to its task view  */
@@ -457,12 +458,14 @@ const handlePopupKey = (ctx, input, key) => {
 };
 /*  handle a key press within the read dialog  */
 const handleDialogKey = (ctx, dialog, input, key) => {
-    const { rows, setDialog, dialogW, tabLabels, dialogSel, dialogScroll, startEdit } = ctx;
+    const { rows, setDialog, dialogW, tabLabels, dialogSel, dialogScroll, dialogDiff, clearDiff, startEdit, watched } = ctx;
     const page = Math.max(1, rows - DIALOG_CHROME - 2);
-    if (key.escape || key.return)
+    if (watched !== undefined ? input === "q" : key.escape || key.return)
         setDialog(null);
     else if (input === "e")
         startEdit(dialog.id);
+    else if (input === "#" && dialogDiff)
+        clearDiff();
     else if (key.leftArrow || key.rightArrow || key.tab) {
         const tab = Math.max(0, Math.min(tabLabels.length - 1, dialogSel + (key.leftArrow || (key.tab && key.shift) ? -1 : 1)));
         setDialog({ ...dialog, tab, first: tabFirst(tabLabels, dialog.first, tab, dialogW - 4) });