@rse/ase 1.0.7 → 2.0.0

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

@@ -0,0 +1,272 @@
+/*
+**  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 crypto from "node:crypto";
+import os from "node:os";
+import { Task } from "./ase-task.js";
+import * as TaskFormat from "./ase-task-format.js";
+import { Agent, updateTask, tagsOf, flatKeys } from "./ase-agent-runtime.js";
+import { skillErrored } from "./ase-agent-runtime-tool.js";
+import { runOwner } from "./ase-agent-runtime-claim.js";
+import { typeParam, attachmentTime, requestRefused, requestDeferred } from "./ase-task-request.js";
+/*  the frontmatter keys of a task plan which are no plan content, as they are
+    changed by the agents and the task boards (and not by the editing of the plan),
+    or maintained by the task stores on every save (like the modification time,
+    which the issue tracker stores even derive from the last update of the issue)  */
+const nonContentKeys = ["Status", "Tags", "Assignee", "Modified"];
+/*  the agent processing the requests attached to tasks (see "TaskRequests") in any task
+    lifecycle model, independent of the status of the tasks (except for refusing the requests
+    of finished tasks and deferring those of tasks in an activity status): it claims the oldest
+    request of a task by turning it into a processed one and assigning the task to the agent
+    (keeping all other agents off it), lets the concrete agent process the prompt of the request
+    via an ASE skill of the headless agent tool, restores the previous assignee, and removes the
+    request if the task plan was changed (else turns it into a failed one, or back into a
+    requested one on interrupt), where a per-process run lock (in the per-user state directory,
+    hence per host and user, see "AgentRun") lets it recover the requests left behind by
+    terminated agents of its kind  */
+export class RequestAgent extends Agent {
+    lifecycles = ["solo", "team", "enterprise"];
+    /*  the claimed requests per task id: their prompt, the previous assignee
+        of the task, and the digest of the plan content right after the claim  */
+    claims = new Map();
+    /*  the assignee under which the agent claims, holds, recognizes, and releases
+        the tasks (default: its name)  */
+    get assignee() {
+        return this.name;
+    }
+    /*  decide on the assignee to hand a processed task <task> over to, by its success
+        and its previous assignee <previous> before the claim (or empty to unassign it):
+        by default, the previous assignee is restored  */
+    handover(_success, previous, _task) {
+        return previous;
+    }
+    /*  whether an attachment type is the one of a request processed by this agent process  */
+    own(type) {
+        return this.requests.state(type) === "active" && typeParam(type, "run") === this.runLock.id;
+    }
+    /*  whether an attachment type is the one of a request processed by an agent process
+        whose run lock is in the same per-user state directory on this host (by its host and
+        owner), i.e., whose termination can be determined (by its run lock and its process id)  */
+    local(type) {
+        return this.requests.state(type) === "active"
+            && typeParam(type, "host") === os.hostname() && typeParam(type, "owner") === runOwner;
+    }
+    /*  the digest of the content of a task plan, as the processing can change it: its
+        frontmatter (except the keys changed by the agents and the task boards, like its
+        status, tags, and assignee) and its body, but none of its attachments (like the
+        requests and the agent processing logs), for detecting whether it was edited  */
+    digest(plan) {
+        const header = Object.fromEntries(Object.entries(plan.header)
+            .filter(([key]) => !nonContentKeys.includes(key)));
+        return crypto.createHash("sha1").update(JSON.stringify({ header, body: plan.body })).digest("hex");
+    }
+    /*  the tag "ase-agent-<kind>:active" of a phase agent holding a task (else empty), which
+        it carries from the claim until the settling by the phase agent, i.e., also while the
+        phase agent still finishes a task already moved into its "success" state by the skill
+        (e.g. commits and publishes its change set), so the task is still neither to be
+        assigned to this agent nor to be edited meanwhile  */
+    held(keys) {
+        return tagsOf(keys).find((tag) => /^ase-agent-[^:]+:active$/.test(tag)
+            && !tag.startsWith(`${this.requests.tag}:`)) ?? "";
+    }
+    /*  recover the requests of terminated agent processes of its kind of the same user
+        on this host (whose run lock is gone or stale and whose process is gone) by marking
+        them as failed and restoring the previous assignee of their tasks, and remove the
+        run locks left behind by them  */
+    async recover() {
+        const runs = await this.runLock.dead();
+        const { items } = await Task.listHeaders(this.log);
+        for (const item of items.filter((item) => this.requests.of(item.keys) === "active")) {
+            const dead = new Set();
+            for (const att of await Task.attachments(this.log, item.id)) {
+                const run = typeParam(att.type, "run");
+                if (this.local(att.type) && !(await this.runLock.alive(run, Number.parseInt(typeParam(att.type, "pid"), 10) || 0)))
+                    dead.add(run);
+            }
+            if (dead.size === 0)
+                continue;
+            await updateTask(this.log, item.id, (plan) => {
+                let changed = false;
+                for (let i = 0; i < plan.attachment.length; i++) {
+                    const type = plan.attachment[i].Type ?? "";
+                    if (this.local(type) && dead.has(typeParam(type, "run"))) {
+                        this.requests.finalize(plan, i, "failed", `failed (${this.role} terminated during processing)`);
+                        changed = true;
+                    }
+                }
+                return changed;
+            });
+            await this.write("warning", this.name, `task "${item.id}": ${this.requests.name} request of terminated ${this.role} marked as failed`);
+        }
+        for (const { run } of runs)
+            await this.runLock.purge(run);
+    }
+    /*  select every task with a request (except one whose finalization is still retried),
+        deferring those in an activity status or still held by a phase agent  */
+    select(items, busy) {
+        const lifecycle = this.lifecycle;
+        const tasks = [];
+        const waiting = new Map();
+        for (const item of items.filter((item) => this.requests.of(item.keys) === "pending" && !busy.has(item.id) && !this.unsettled.has(item.id))) {
+            const held = this.held(item.keys);
+            if (requestDeferred(lifecycle, item.status))
+                waiting.set(item.id, `its status "${item.status}" to change`);
+            else if (held !== "")
+                waiting.set(item.id, `its tag "${held}" to be released`);
+            else
+                tasks.push({ id: item.id, title: item.title, keys: item.keys });
+        }
+        return { tasks, waiting };
+    }
+    /*  claim the oldest request of a task, in a single conditional update of the
+        task (so a concurrent claim, e.g. by a phase agent, makes it fail): turn the request
+        into a processed one and assign the task to the agent (remembering its previous
+        assignee), which keeps all other agents off the task during its processing, where the
+        request of a finished task is marked as failed instead, and a task meanwhile in an
+        activity status or meanwhile held by a phase agent is skipped, and a request without
+        a prompt is marked as failed (unless the agent ignores the prompts of its requests)  */
+    async claim(task) {
+        const lifecycle = this.lifecycle;
+        let status = "";
+        let prompt = "";
+        let assignee = "";
+        let sum = "";
+        let refused = "";
+        let claimed = false;
+        await updateTask(this.log, task.id, (plan) => {
+            status = TaskFormat.taskStatus(plan.header, lifecycle);
+            prompt = "";
+            refused = "";
+            claimed = false;
+            /*  adopt a request already claimed by this run, as found by an update
+                retried after a saved claim whose response was lost  */
+            const own = plan.attachment.find((att) => this.own(att.Type ?? ""));
+            if (own !== undefined) {
+                prompt = (own.Data ?? "").trim();
+                assignee = typeParam(own.Type ?? "", "assignee");
+                sum = this.digest(plan);
+                claimed = true;
+                return false;
+            }
+            const i = plan.attachment.findIndex((att) => this.requests.state(att.Type ?? "") === "pending");
+            if (i < 0 || requestDeferred(lifecycle, status) || this.requests.running(plan)
+                || this.held(flatKeys(plan.header)) !== "")
+                return false;
+            const att = plan.attachment[i];
+            if (requestRefused(lifecycle, status))
+                refused = `task is finished, status "${status}"`;
+            else if ((att.Data ?? "").trim() === "" && this.presencePrompt === "required")
+                refused = "empty prompt";
+            if (refused !== "")
+                plan.attachment[i] = { ...att, Type: this.requests.type("failed"), Desc: `failed (${refused})`, Modified: attachmentTime() };
+            else {
+                prompt = (att.Data ?? "").trim();
+                assignee = String(plan.header.Assignee ?? "");
+                claimed = true;
+                const params = {
+                    agent: this.assignee, assignee, host: os.hostname(), owner: runOwner,
+                    pid: String(process.pid), run: this.runLock.id
+                };
+                plan.attachment[i] = { ...att, Type: this.requests.type("active", params), Modified: attachmentTime() };
+                plan.header.Assignee = this.assignee;
+            }
+            this.requests.retag(plan);
+            sum = this.digest(plan);
+            return true;
+        });
+        if (refused !== "") {
+            await this.write("warning", this.name, `task "${task.id}": ${this.requests.name} request refused (${refused})`);
+            return null;
+        }
+        else if (!claimed)
+            return null;
+        this.claims.set(task.id, { prompt, assignee, digest: sum });
+        return `claimed ${this.requests.name} request (status "${status}", assigned to "${this.assignee}"` +
+            (assignee !== "" ? ` instead of "${assignee}")` : ")");
+    }
+    /*  decide whether the processing of a request failed, returning the reason of the failure,
+        or null on success (called within the settling update of the task, with its current plan,
+        so it must neither change the plan nor block): by default, the processing succeeded only if
+        the plan content changed since the claim and the skill reported no error (independent of the
+        exit code of the agent tool and an interrupt, as the plan is saved at once), where a concrete
+        agent whose processing succeeds without changing the plan (e.g. one producing an attachment
+        or an external result only) overrides this with its own success criterion  */
+    failure(outcome) {
+        const { changed, errored, ok } = outcome;
+        return changed && !errored ? null : errored ? "skill reported an error" : !ok ? "agent tool failed" : "plan not changed";
+    }
+    /*  settle the processed request in a single update of the task: if the processing succeeded
+        (see "failure"), the request is removed, else it is turned back into a requested one on
+        interrupt, or into a failed one otherwise, and in all cases the previous assignee of the task
+        is restored (or the task is handed over, see "handover"); a finalization failing even after
+        its retries is retried in the background
+        (see "unsettle"), so the request never stays processed  */
+    async settle(task, ok, _finished, aborted, output, log) {
+        const claim = this.claims.get(task.id);
+        this.claims.delete(task.id);
+        if (claim === undefined)
+            return;
+        const errored = skillErrored(output);
+        let result = "";
+        let success = false;
+        const finish = () => updateTask(this.log, task.id, (plan) => {
+            success = false;
+            const i = plan.attachment.findIndex((att) => this.own(att.Type ?? ""));
+            if (i < 0) {
+                /*  the request vanished meanwhile: just restore the assignee and the tag  */
+                const before = JSON.stringify([plan.header.Assignee, plan.header.Tags]);
+                if (String(plan.header.Assignee ?? "") === this.assignee) {
+                    if (claim.assignee !== "")
+                        plan.header.Assignee = claim.assignee;
+                    else
+                        delete plan.header.Assignee;
+                }
+                this.requests.retag(plan);
+                result = `${this.requests.name} request vanished meanwhile`;
+                return JSON.stringify([plan.header.Assignee, plan.header.Tags]) !== before;
+            }
+            const changed = this.digest(plan) !== claim.digest;
+            const reason = this.failure({ id: task.id, plan, changed, errored, ok, aborted, output });
+            if (reason === null) {
+                this.requests.finalize(plan, i, null, undefined, this.handover(true, claim.assignee, task));
+                result = `task ${this.requests.done} successfully (request removed)`;
+                success = true;
+            }
+            else if (aborted) {
+                this.requests.finalize(plan, i, "pending");
+                result = `${this.requests.name} request released (requested again)`;
+            }
+            else {
+                this.requests.finalize(plan, i, "failed", `failed (${reason}, see attachment "agent")`, this.handover(false, claim.assignee, task));
+                result = `task not ${this.requests.done} (${reason}, request marked as failed)`;
+            }
+            return true;
+        });
+        let exists;
+        try {
+            exists = await finish();
+        }
+        catch (err) {
+            /*  the retried finalization reports its result itself (as the processing log of
+                the task is already closed), or the vanishing of the task, which ends the retries  */
+            this.unsettle(task.id, async () => {
+                const exists = await finish();
+                await this.write(exists ? (success ? "info" : "warning") : "warning", `${this.name}: ${task.id}`, exists ? `${result} (finalization retried)` : "task vanished -- finalization of the request dropped", undefined, task.id);
+                return true;
+            });
+            await log("error", `finalizing the ${this.requests.name} request failed (retried later): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        if (exists)
+            await log(success ? "info" : "warning", result);
+        else
+            await log("warning", "task vanished meanwhile");
+    }
+    /*  the description of the observed tasks (for the start log line)  */
+    observing() {
+        return `tasks tagged with "${this.requests.tag}:pending"`;
+    }
+}

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

@@ -0,0 +1,207 @@
+/*
+**  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 { stripVTControlCharacters } from "node:util";
+/*  the maximum number of lines of an agent message kept in the processing log attachment
+    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 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
+    (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",
+        "--permission-mode", "auto", "--permission-prompts", "none", prompt
+    ],
+    "copilot": (prompt, add) => [
+        ...add, "--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
+    ]
+};
+/*  the per-tool rendering of the invocation of the skill <skill> with the arguments <args>:
+    "/<skill>" for Claude and Copilot and "$<skill>" for Codex, where an un-namespaced ASE
+    skill ("ase-*") gets the plugin namespace "ase:" for Claude only (as Copilot and Codex
+    invoke the plugin skills un-namespaced), and the arguments are appended with a single
+    space only if non-empty  */
+export const skillPrompt = (tool, skill, args) => {
+    const name = tool === "claude" && skill.startsWith("ase-") && !skill.includes(":") ? `ase:${skill}` : skill;
+    return `${tool === "codex" ? "$" : "/"}${name}${args !== "" ? ` ${args}` : ""}`;
+};
+/*  abbreviate a value into a single line of at most <max> characters  */
+const brief = (value, max = 160) => {
+    const line = (typeof value === "string" ? value : JSON.stringify(value) ?? "").replace(/\s+/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+};
+/*  the constructors of processing log entries: informational, warning,
+    warning on failure (else informational), and agent message text  */
+const info = (msg) => ({ level: "info", msg });
+const warn = (msg) => ({ level: "warning", msg });
+const note = (failed, msg) => failed ? warn(msg) : info(msg);
+const text = (msg) => ({ level: "info", msg, text: true });
+/*  the per-tool decoding of a JSONL event of the agent tool into processing log entries,
+    covering agent messages, tool calls, failures, and the final result only  */
+const toolEvents = {
+    "claude": (ev) => {
+        const content = Array.isArray(ev.message?.content) ? ev.message.content : [];
+        if (ev.type === "system" && ev.subtype === "init")
+            return [info(`session ${ev.session_id} started (model: ${ev.model})`)];
+        else if (ev.type === "system" && ev.subtype === "api_retry")
+            return [warn(`API retry ${ev.attempt}/${ev.max_retries} (error: ${ev.error})`)];
+        else if (ev.type === "assistant")
+            return content.filter((block) => block.type === "text" || block.type === "tool_use")
+                .map((block) => block.type === "text" ? text(block.text) : info(`tool ${block.name}: ${brief(block.input)}`));
+        else if (ev.type === "user")
+            return content.filter((block) => block.type === "tool_result" && block.is_error === true)
+                .map((block) => warn(`tool failed: ${brief(block.content)}`));
+        else if (ev.type === "result")
+            return [
+                ...(Array.isArray(ev.permission_denials) ? ev.permission_denials : [])
+                    .map((denial) => warn(`permission denied: tool ${denial.tool_name}: ${brief(denial.tool_input)}`)),
+                note(ev.is_error === true, `result: ${ev.subtype} (turns: ${ev.num_turns}, ` +
+                    `duration: ${Math.round((ev.duration_ms ?? 0) / 1000)}s, cost: $${Number(ev.total_cost_usd ?? 0).toFixed(2)})`)
+            ];
+        return [];
+    },
+    "copilot": (ev) => {
+        const data = ev.data ?? {};
+        if (ev.type === "session.start")
+            return [info(`session ${data.sessionId} started (model: ${data.selectedModel ?? "default"})`)];
+        else if (ev.type === "assistant.message" && typeof data.content === "string" && data.content !== "")
+            return [text(data.content)];
+        else if (ev.type === "tool.execution_start")
+            return [info(`tool ${data.toolName}: ${brief(data.arguments ?? {})}`)];
+        else if (ev.type === "tool.execution_complete" && data.success !== true)
+            return [warn(`tool failed: ${brief(data.error?.message ?? data.result?.content ?? "")}`)];
+        else if (ev.type === "subagent.failed")
+            return [warn(`sub-agent ${data.agentName} failed: ${brief(data.error)}`)];
+        else if (ev.type === "session.error" || ev.type === "session.warning")
+            return [warn(`${ev.type.replace(/^session\./, "")}: ${brief(data.message)}`)];
+        else if (ev.type === "result")
+            return [note(ev.exitCode !== 0, `result: exit code ${ev.exitCode} ` +
+                    `(duration: ${Math.round((ev.usage?.sessionDurationMs ?? 0) / 1000)}s, ` +
+                    `premium requests: ${ev.usage?.premiumRequests ?? 0})`)];
+        return [];
+    },
+    "codex": (ev) => {
+        const item = ev.item ?? {};
+        const done = ev.type === "item.completed";
+        if (ev.type === "thread.started")
+            return [info(`thread ${ev.thread_id} started`)];
+        else if (ev.type === "item.started" && item.type === "command_execution")
+            return [info(`command: ${brief(item.command)}`)];
+        else if (ev.type === "item.started" && item.type === "mcp_tool_call")
+            return [info(`tool ${item.server}/${item.tool}: ${brief(item.arguments ?? {})}`)];
+        else if (done && item.type === "agent_message")
+            return [text(item.text)];
+        else if (done && item.type === "command_execution" && item.status !== "completed")
+            return [warn(`command ${item.status} (exit code ${item.exit_code ?? "none"}): ${brief(item.command)}`)];
+        else if (done && item.type === "mcp_tool_call" && item.status !== "completed")
+            return [warn(`tool ${item.server}/${item.tool} failed: ${brief(item.error?.message ?? "")}`)];
+        else if (done && item.type === "file_change")
+            return [note(item.status !== "completed", `file change ${item.status}: ` +
+                    (Array.isArray(item.changes) ? item.changes : []).map((change) => `${change.kind} ${change.path}`).join(", "))];
+        else if (done && item.type === "web_search")
+            return [info(`web search: ${brief(item.query)}`)];
+        else if (done && item.type === "error")
+            return [warn(`error: ${brief(item.message)}`)];
+        else if (ev.type === "turn.completed")
+            return [info(`turn completed (tokens: input ${ev.usage?.input_tokens ?? 0}, output ${ev.usage?.output_tokens ?? 0})`)];
+        else if (ev.type === "turn.failed")
+            return [warn(`turn failed: ${brief(ev.error?.message)}`)];
+        else if (ev.type === "error")
+            return [warn(`error: ${brief(ev.message)}`)];
+        return [];
+    }
+};
+/*  a reported amount (where a missing or invalid one counts as zero)  */
+const amount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+/*  the per-tool accounting of a JSONL event of the agent tool into its costs: the output tokens
+    (as the input tokens are dominated by the context re-sent on every turn) and the costs in USD
+    of Claude (over all its models, i.e. including its sub-agents, from its final result), nothing
+    of Copilot (as it reports premium requests only), and the output tokens of Codex (summed over
+    its turns), plus the cache and input tokens and the AI request time where reported (where
+    the input tokens of Claude exclude the cache tokens, while those of Codex include them)  */
+const toolCosts = {
+    "claude": (ev, costs) => {
+        if (ev.type !== "result")
+            return;
+        const models = ev.modelUsage !== null && typeof ev.modelUsage === "object" ? Object.values(ev.modelUsage) : [];
+        const sum = (key, fallback) => models.length > 0 ?
+            models.reduce((acc, u) => acc + amount(u?.[key]), 0) :
+            amount(ev.usage?.[fallback]);
+        costs.costToken = sum("outputTokens", "output_tokens");
+        costs.cread = sum("cacheReadInputTokens", "cache_read_input_tokens");
+        costs.cwrite = sum("cacheCreationInputTokens", "cache_creation_input_tokens");
+        costs.input = sum("inputTokens", "input_tokens");
+        costs.costUSD = amount(ev.total_cost_usd);
+        costs.apiMs = typeof ev.duration_api_ms === "number" ? amount(ev.duration_api_ms) : null;
+    },
+    "copilot": (ev, costs) => {
+        /*  no tokens and costs reported  */
+        if (ev.type === "result" && ev.usage?.sessionDurationMs !== undefined)
+            costs.apiMs = amount(ev.usage.sessionDurationMs);
+    },
+    "codex": (ev, costs) => {
+        if (ev.type === "turn.completed") {
+            const cread = amount(ev.usage?.cached_input_tokens);
+            const cwrite = amount(ev.usage?.cache_write_input_tokens);
+            costs.costToken = (costs.costToken ?? 0) + amount(ev.usage?.output_tokens);
+            costs.cread += cread;
+            costs.cwrite += cwrite;
+            costs.input += Math.max(0, amount(ev.usage?.input_tokens) - cread - cwrite);
+        }
+    }
+};
+/*  decode an output line of the agent tool into processing log entries without
+    terminal control sequences: a JSONL event via the decoder of the tool (splitting
+    agent message text into its lines, and accounting it into the costs), and any
+    other non-blank line as plain text  */
+export const toolEntries = (tool, line, costs) => {
+    let ev = null;
+    if (line.startsWith("{")) {
+        try {
+            ev = JSON.parse(line);
+        }
+        catch (_e) {
+            /*  not a JSONL event: treat as plain text  */
+        }
+    }
+    if (ev === null || typeof ev !== "object") {
+        const plain = stripVTControlCharacters(line);
+        return plain.trim() !== "" ? [text(plain)] : [];
+    }
+    toolCosts[tool](ev, costs);
+    return toolEvents[tool](ev).flatMap((entry) => {
+        if (entry.text !== true)
+            return [{ ...entry, msg: stripVTControlCharacters(entry.msg) }];
+        const msgs = stripVTControlCharacters(entry.msg).replace(/\n+$/, "").split("\n");
+        return [
+            ...msgs.map((msg, i) => ({ ...text(msg), ...(i >= TEXT_MAX ? { quiet: true } : {}) })),
+            ...(msgs.length > TEXT_MAX ? [info(`(${msgs.length - TEXT_MAX} further lines of agent message ` +
+                    "not kept in the processing log of the task)")] : [])
+        ];
+    });
+};
+/*  whether a skill reported an error in the output lines of the headless agent tool, as the
+    skills report their errors as "▶ ERROR: ..." (see "ase-common-task") while the agent tool
+    still exits successfully, where an agent message merely quoting "ERROR:" (e.g. of some
+    code or log) is no error  */
+export const skillErrored = (output) => output.some((line) => /(?:^|▶ )ERROR:/.test(line.trim()));
+/*  the last verdict word following the label <label> in the output lines of a skill
+    (e.g. "APPROVE" of "**REVIEW VERDICT**: **APPROVE**"), or empty if none  */
+export const verdictOf = (output, label) => {
+    const re = new RegExp(`${label}\\W*([A-Z]+)`);
+    let verdict = "";
+    for (const line of output) {
+        const m = re.exec(line);
+        if (m !== null)
+            verdict = m[1];
+    }
+    return verdict;
+};