@rse/ase 2.0.1 → 2.0.3

package/dst/ase-task-board-web-server.js

@@ -18,7 +18,7 @@ import { flowOf, layoutFlow, drawFlowSVG } from "./ase-task-board-flow.js";
 import { filterBoard, dropStandalone } from "./ase-task-board-filter.js";
 import { statsOf, statsRanges, effortScale } from "./ase-task-board-stats.js";
 import * as TaskFormat from "./ase-task-format.js";
-import { editProbe, editRefused, requestEdit, requestsOf, RequestError } from "./ase-task-request.js";
+import { editProbe, editRefused, requestsOf, RequestError } from "./ase-task-request.js";
 import pkg from "../package.json" with { type: "json" };
 /*  the build stamp of the loaded code (version and content hash of the board modules
     and page assets), reported by the ping route to let the CLI detect a stale running service
@@ -26,7 +26,7 @@ import pkg from "../package.json" with { type: "json" };
 export const BOARD_BUILD = (() => {
     const dir = path.dirname(fileURLToPath(import.meta.url));
     const hash = crypto.createHash("sha1");
-    for (const f of ["core.js", "filter.js", "graph.js", "stats.js", "web-server.js", "web-client.html", "web-client.css", "web-client.js"])
+    for (const f of ["core.js", "filter.js", "flow.js", "graph.js", "stats.js", "web-server.js", "web-client.html", "web-client.css", "web-client.js"])
         hash.update(fs.readFileSync(path.join(dir, `ase-task-board-${f}`)));
     return `${pkg.version}:${hash.digest("hex")}`;
 })();
@@ -192,7 +192,7 @@ const attachmentDocument = async (log, id, n) => {
         try {
             text = new TextDecoder("utf-8", { fatal: true }).decode(a.content);
         }
-        catch (_err) {
+        catch {
             text = "\0";
         }
         if (text.includes("\0"))
@@ -364,7 +364,7 @@ const registerPageRoutes = (server, log) => {
 };
 /*  the filter query of a request (its optional "filter" query parameter)  */
 const filterQuery = (request) => typeof request.query.filter === "string" ? request.query.filter : "";
-/*  register the view routes of the web board: the board, the graph, the statistics, and the tasks with their attachments  */
+/*  register the view routes of the web board: the board, the task and agent graphs, the statistics, the new task text, and the tasks with their attachments  */
 const registerViewRoutes = (server, log) => {
     /*  the board model, reduced onto the tasks matching the filter query  */
     server.route({
@@ -637,29 +637,6 @@ const registerUpdateRoutes = (server, log) => {
             return h.response({ prompt: probe.prompt });
         })
     });
-    /*  request the edit of a task by a prompt (processed by "ase agent editor"), answering
-        400 if the prompt is empty, 404 if the task is missing, and 409 if it is finished or
-        an edit of it is in progress (as checked atomically with the request)  */
-    server.route({
-        method: "POST",
-        path: "/task-board/api/task/{id}/edit",
-        options: { payload: { parse: true, allow: "application/json" } },
-        handler: guarded(async (request, h) => {
-            const id = String(request.params.id);
-            const p = request.payload;
-            if (!TaskFormat.TASK_ID_RE.test(id) || p === null || typeof p.prompt !== "string")
-                return h.response({ error: "invalid edit request" }).code(400);
-            try {
-                await requestEdit(log, id, p.prompt);
-            }
-            catch (err) {
-                const code = !(err instanceof RequestError) || err.reason === "empty" ? 400 :
-                    err.reason === "missing" ? 404 : 409;
-                return h.response({ error: err instanceof Error ? err.message : String(err) }).code(code);
-            }
-            return h.response({ ok: true });
-        })
-    });
     /*  request a task by a prompt under a request name (processed by a request agent of
         a definition, resp. by "ase agent editor" for "edit"), answering 400 if the
         request name is invalid or the prompt of an "edit" request is empty (as the prompts

package/dst/ase-task-board.js

@@ -78,7 +78,7 @@ export default class TaskBoardCommand {
                 "(restart it with \"ase service stop\" once no agent session uses it)");
         return port;
     }
-    /*  open an URL in the default browser of the platform, waiting only for
+    /*  open a URL in the default browser of the platform, waiting only for
         the opener to spawn, as e.g. "xdg-open" can stay attached to the browser  */
     async openBrowser(url) {
         const [cmd, ...args] = process.platform === "darwin" ? ["open", url] :

package/dst/ase-task-format.js

@@ -745,7 +745,7 @@ export const bindEffort = (plan) => {
     if (effort !== null && effort.hash === "")
         plan.header.Effort = `${effort.size} ${hash}`;
     else if (effort === null || effort.hash !== hash)
-        Reflect.deleteProperty(plan.header, "Effort");
+        delete plan.header.Effort;
     return plan;
 };
 /*  derive the title of a task plan from its body as defined by the

package/dst/ase-task-store-client.js

@@ -58,6 +58,7 @@ export class LocalTaskStoreClient {
         this.configure("project.task.idscheme", spec);
         this.idscheme = (await this.core.projectSet(this.prjId, { idscheme: spec })).project.idscheme;
     }
+    /*  run an operation, yielding a fallback for a missing (404) task plan  */
     async missing(op, fallback) {
         try {
             return await op();
@@ -68,6 +69,7 @@ export class LocalTaskStoreClient {
             throw err;
         }
     }
+    /*  open the storage delegate shared by all clients of the store and register the project  */
     async open() {
         let entry = LocalTaskStoreClient.shared.get(this.storage.key);
         if (entry === undefined) {
@@ -99,6 +101,7 @@ export class LocalTaskStoreClient {
             throw err;
         }
     }
+    /*  release the shared storage delegate, closing it with its last client  */
     async close() {
         const entry = this.entry;
         if (entry === undefined)
@@ -107,7 +110,9 @@ export class LocalTaskStoreClient {
         if (--entry.refs === 0) {
             if (LocalTaskStoreClient.shared.get(this.storage.key) === entry)
                 LocalTaskStoreClient.shared.delete(this.storage.key);
-            await entry.opened.then((opened) => opened.store.close(), () => { });
+            await entry.opened.then((opened) => opened.store.close(), () => {
+                /*  a failed opening was already raised to its opener  */
+            });
         }
     }
     list(fields) {
@@ -153,11 +158,13 @@ export class LocalTaskStoreClient {
                 onChange();
         };
         let stopped = false;
+        let started = false;
         const start = async () => {
             await this.open();
             if (stopped)
                 await this.close();
             else {
+                started = true;
                 this.entry?.listeners.add(listener);
                 onState?.(true);
             }
@@ -167,6 +174,8 @@ export class LocalTaskStoreClient {
         });
         return () => {
             stopped = true;
+            if (!started)
+                return;
             this.entry?.listeners.delete(listener);
             this.close().catch(() => { });
         };
@@ -174,9 +183,10 @@ export class LocalTaskStoreClient {
 }
 /*  the interval of the keepalive pings of the event subscription (where a connection without
     any traffic for this interval is pinged and without any traffic for twice this interval
-    is terminated) and the timeout of its WebSocket handshake  */
+    is terminated), the timeout of its WebSocket handshake, and the timeout of the REST API requests  */
 const KEEPALIVE_MS = 15 * 1000;
 const HANDSHAKE_MS = 10 * 1000;
+const REQUEST_MS = 10 * 1000;
 /*  the remote client: the REST API of a task store server, with the
     project registered under its configured lifecycle model and task id
     scheme on first use only (afterwards adopting the lifecycle model and
@@ -231,7 +241,7 @@ export class RemoteTaskStoreClient {
             },
             body: body !== undefined ? JSON.stringify(body) : undefined,
             dispatcher: this.dispatcher,
-            signal: AbortSignal.timeout(10000),
+            signal: AbortSignal.timeout(REQUEST_MS),
             ignoreResponseError: true
         }).catch((err) => this.unreachable(err));
         if (r.status === 404 || tolerated.includes(r.status))
@@ -402,7 +412,7 @@ export class RemoteTaskStoreClient {
             headers: { Authorization: `Bearer ${this.token}` },
             responseType: "arrayBuffer",
             dispatcher: this.dispatcher,
-            signal: AbortSignal.timeout(10000),
+            signal: AbortSignal.timeout(REQUEST_MS),
             ignoreResponseError: true
         }).catch((err) => this.unreachable(err));
         if (r.status === 404)
@@ -489,7 +499,9 @@ export class RemoteTaskStoreClient {
             if (timer !== null)
                 clearTimeout(timer);
             ws?.close();
-            this.close().catch(() => { });
+            this.close().catch(() => {
+                /*  best-effort release of the dispatcher on unsubscribe  */
+            });
         };
     }
 }

package/dst/ase-task-store-core.js

@@ -143,7 +143,7 @@ export class TaskStoreCore {
         if (effort !== undefined)
             header.Effort = effort;
         else
-            Reflect.deleteProperty(header, "Effort");
+            delete header.Effort;
         return header;
     }
     /*  load an existing task plan of a registered project  */
@@ -408,7 +408,7 @@ export class TaskStoreCore {
                 if (lifecycle.states.includes(status) && !states.includes(status))
                     continue;
                 const att = fields === "usage" ? (await this.store.taskLoad(prjId, entry.id))?.attachment
-                    .find((att) => TaskFormat.isUsage(att) && att.Data !== undefined) : undefined;
+                    .find((a) => TaskFormat.isUsage(a) && a.Data !== undefined) : undefined;
                 const header = fields === "header" ? await this.boundHeader(prjId, entry) : entry.header;
                 result.push({
                     id: entry.id,
@@ -605,12 +605,10 @@ export class TaskStoreCore {
                     references: referrers.length
                 };
             }
-            else {
-                await this.store.taskSave(prjId, taskId, plan);
-                this.emitUpdated(prjId, taskId, plan, lifecycle, ["header"]);
-            }
+            await this.store.taskSave(prjId, taskId, plan);
+            this.emitUpdated(prjId, taskId, plan, lifecycle, ["header"]);
             return {
-                id: newId ?? taskId,
+                id: taskId,
                 status: TaskFormat.taskStatus(plan.header, lifecycle),
                 ...(status !== null ? { from } : {})
             };

package/dst/ase-task-store-issues.js

@@ -235,3 +235,94 @@ export const attachmentSync = (current, wanted) => {
     }
     return ops;
 };
+/*  reuse the cached promise of a load, else start the load and cache its promise
+    (dropped again on failure), so repeated and concurrent loads share one request  */
+export const memoize = (cache, key, load) => {
+    let promise = cache.get(key);
+    if (promise === undefined) {
+        promise = load();
+        cache.set(key, promise);
+        promise.catch(() => {
+            cache.delete(key);
+        });
+    }
+    return promise;
+};
+/*  the common base of the issue tracker storage plugins: the projects mapped onto
+    their locations, the storage lifecycle polling for changes while opened and
+    observed (without keeping the process alive), and the project listing  */
+export class IssueTaskStoragePlugin {
+    ctx;
+    unit;
+    now;
+    url = "";
+    poll = 0;
+    repos = new Map();
+    listener = null;
+    timer = null;
+    opened;
+    polling = false;
+    polls = new Map();
+    constructor(ctx, unit, now) {
+        this.ctx = ctx;
+        this.unit = unit;
+        this.now = now;
+        this.opened = now();
+    }
+    /*  the storage lifecycle  */
+    async open() {
+        this.opened = this.now();
+        if (this.poll > 0 && this.listener !== null) {
+            this.timer = setInterval(() => {
+                this.pollAll().catch(() => {
+                    /*  failures are already logged per project  */
+                });
+            }, this.poll * 1000);
+            this.timer.unref();
+        }
+        this.ctx.log("debug", `opened ${this.repos.size} ${this.unit} on ${this.url} (polling every ${this.poll}s)`);
+    }
+    async close() {
+        if (this.timer !== null)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    /*  observe the changes of the issues made outside of this plugin instance  */
+    watch(listener) {
+        this.listener = listener;
+    }
+    /*  list the registered ones of the mapped projects  */
+    async projectList() {
+        const out = [];
+        for (const prjId of this.repos.keys()) {
+            const entry = await this.projectGet(prjId);
+            if (entry !== null)
+                out.push(entry);
+        }
+        return out;
+    }
+    /*  the change detection state of a project (starting at the opening time)  */
+    pollState(prjId) {
+        let state = this.polls.get(prjId);
+        if (state === undefined) {
+            state = { since: this.opened, seen: new Map() };
+            this.polls.set(prjId, state);
+        }
+        return state;
+    }
+    /*  poll all mapped projects, never overlapping itself  */
+    async pollAll() {
+        if (this.polling)
+            return;
+        this.polling = true;
+        try {
+            for (const prjId of this.repos.keys())
+                await this.pollProject(prjId).catch((err) => {
+                    this.ctx.log("warning", `polling project "${prjId}" failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+}

package/dst/ase-task-store-plugin-ase.js

@@ -143,7 +143,7 @@ class FileTaskStoragePlugin {
             doc = parseYAML(text);
         }
         catch (err) {
-            this.ctx.log("warning", `malformed project file "${file}" ignored: ${err.message}`);
+            this.ctx.log("warning", `malformed project file "${file}" ignored: ${err instanceof Error ? err.message : String(err)}`);
             return { lifecycle: this.lifecycle, idscheme: this.idscheme, seqmark: 0, broken: true };
         }
         return {
@@ -339,7 +339,9 @@ class FileTaskStoragePlugin {
                 if (this.watcher !== w)
                     return;
                 this.watcher = null;
-                w.close().catch(() => { }).finally(() => {
+                w.close().catch(() => {
+                    /*  re-arm even if the outdated watcher fails to close  */
+                }).finally(() => {
                     this.arm();
                     this.schedule();
                 });
@@ -418,7 +420,9 @@ class FileTaskStoragePlugin {
             clearTimeout(this.timer);
         this.timer = setTimeout(() => {
             this.timer = null;
-            this.rescan().catch(() => { });
+            this.rescan().catch(() => {
+                /*  failures are already logged per directory  */
+            });
         }, 100);
         this.timer.unref();
     }

package/dst/ase-task-store-plugin-gitea.js

@@ -50,19 +50,10 @@ const inRepo = (loc, issue) => issue.repository === undefined || issue.repositor
     "After" onto the dependencies (the blocking issues), "Created"/"Modified" onto the
     issue timestamps, any other key (including "Group", as Gitea has no parent issues)
     onto "ase:<key>:<value>" labels, and the attachments onto the issue comments  */
-class GiteaTaskStoragePlugin {
-    ctx;
+class GiteaTaskStoragePlugin extends TaskIssues.IssueTaskStoragePlugin {
     name = "gitea";
-    url;
     source;
     gt;
-    repos = new Map();
-    poll;
-    listener = null;
-    timer = null;
-    polling = false;
-    opened = now();
-    polls = new Map();
     registry = new LRUCache({ max: 64, ttl: 60 * 1000 });
     latest = new Map();
     labels = new Map();
@@ -71,7 +62,7 @@ class GiteaTaskStoragePlugin {
     depends = new LRUCache({ max: 1024, ttl: 60 * 1000 });
     loads = new LRUCache({ max: 256, ttl: 2 * 1000 });
     constructor(ctx) {
-        this.ctx = ctx;
+        super(ctx, "repositories", now);
         const options = ctx.options;
         const token = options.token ?? process.env.GITEA_TOKEN ?? "";
         if (typeof token !== "string" || token === "")
@@ -147,27 +138,6 @@ class GiteaTaskStoragePlugin {
                 return out;
         }
     }
-    /*  the storage lifecycle: polling for changes while opened and observed
-        (without keeping the process alive)  */
-    async open() {
-        this.opened = now();
-        if (this.poll > 0 && this.listener !== null) {
-            this.timer = setInterval(() => {
-                this.pollAll().catch(() => { });
-            }, this.poll * 1000);
-            this.timer.unref();
-        }
-        this.ctx.log("debug", `opened ${this.repos.size} repositories on ${this.url} (polling every ${this.poll}s)`);
-    }
-    async close() {
-        if (this.timer !== null)
-            clearInterval(this.timer);
-        this.timer = null;
-    }
-    /*  observe the changes of the issues made outside of this plugin instance  */
-    watch(listener) {
-        this.listener = listener;
-    }
     /*  ==== project registry ====  */
     /*  the repository of a project  */
     repo(prjId) {
@@ -240,15 +210,6 @@ class GiteaTaskStoragePlugin {
     async seqmark(loc, entry, fresh = false) {
         return Math.max(await this.latestNumber(loc, fresh), entry?.seqmark ?? 0);
     }
-    async projectList() {
-        const out = [];
-        for (const prjId of this.repos.keys()) {
-            const entry = await this.projectGet(prjId);
-            if (entry !== null)
-                out.push(entry);
-        }
-        return out;
-    }
     /*  get a project, with the sequence number high-water mark as the next
         allocated task id is the one of the next created issue  */
     async projectGet(prjId) {
@@ -287,7 +248,7 @@ class GiteaTaskStoragePlugin {
             await found(this.call(loc, this.gt.repos.issueDeleteLabel(loc.owner, loc.repo, label.id)).then(() => true)) : null;
         this.labels.delete(`${loc.owner}/${loc.repo}`);
         this.registry.delete(prjId);
-        return label !== undefined && result !== null;
+        return result !== null;
     }
     /*  ==== issue mapping ====  */
     /*  fetch the live issue of an issue number (null if none)  */
@@ -303,15 +264,8 @@ class GiteaTaskStoragePlugin {
         const key = `${loc.owner}/${loc.repo}#${issue.number}@${issue.updated_at}`;
         if (fresh)
             this.depends.delete(key);
-        let depends = this.depends.get(key);
-        if (depends === undefined) {
-            depends = found(this.all(loc, (query) => this.gt.repos.issueListIssueDependencies(loc.owner, loc.repo, String(issue.number), query)))
-                .then((issues) => (issues ?? []));
-            this.depends.set(key, depends);
-            depends.catch(() => {
-                this.depends.delete(key);
-            });
-        }
+        const depends = TaskIssues.memoize(this.depends, key, () => found(this.all(loc, (query) => this.gt.repos.issueListIssueDependencies(loc.owner, loc.repo, String(issue.number), query)))
+            .then((issues) => (issues ?? [])));
         return (await depends).filter((blocker) => inRepo(loc, blocker));
     }
     /*  the comments of an issue  */
@@ -362,10 +316,10 @@ class GiteaTaskStoragePlugin {
             if (label === undefined) {
                 label = await this.call(loc, this.gt.repos.issueCreateLabel(loc.owner, loc.repo, { name, color: name.startsWith("ase:") ? "#c5def5" : "#ededed" })).catch(async (err) => {
                     /*  tolerate a label created concurrently  */
-                    const label = statusOf(err) === 422 ? (await this.labelMap(loc, true)).get(name.toLowerCase()) : undefined;
-                    if (label === undefined)
+                    const existing = statusOf(err) === 422 ? (await this.labelMap(loc, true)).get(name.toLowerCase()) : undefined;
+                    if (existing === undefined)
                         throw err;
-                    return label;
+                    return existing;
                 });
                 const map = await this.labelMap(loc);
                 map.set(name.toLowerCase(), label);
@@ -422,15 +376,8 @@ class GiteaTaskStoragePlugin {
         if (typeof assignee === "string" && assignee !== "") {
             const logins = issue?.assignees?.map((user) => user.login) ?? [];
             const key = `${loc.owner}/${loc.repo}`;
-            let users = this.assignable.get(key);
-            if (users === undefined) {
-                users = this.call(loc, this.gt.repos.repoGetAssignees(loc.owner, loc.repo))
-                    .then((list) => new Set(list.map((user) => (user.login ?? "").toLowerCase())));
-                this.assignable.set(key, users);
-                users.catch(() => {
-                    this.assignable.delete(key);
-                });
-            }
+            const users = TaskIssues.memoize(this.assignable, key, () => this.call(loc, this.gt.repos.repoGetAssignees(loc.owner, loc.repo))
+                .then((list) => new Set(list.map((user) => (user.login ?? "").toLowerCase()))));
             if (logins.includes(assignee))
                 assignees = logins;
             else if ((await users).has(assignee.toLowerCase()))
@@ -486,11 +433,7 @@ class GiteaTaskStoragePlugin {
         own write or detected change of the issue), as e.g. the boards load the plan
         and its attachments in separate operations  */
     load(prjId, loc, n) {
-        const key = `${prjId}#${n}`;
-        const cached = this.loads.get(key);
-        if (cached !== undefined)
-            return cached;
-        const load = (async () => {
+        return TaskIssues.memoize(this.loads, `${prjId}#${n}`, async () => {
             const [issue, comments] = await Promise.all([
                 this.fetch(loc, n),
                 n === 0 ? [] : found(this.comments(loc, n))
@@ -498,12 +441,7 @@ class GiteaTaskStoragePlugin {
             if (issue === null)
                 return null;
             return { issue, after: await this.blockers(loc, issue), comments: comments ?? [] };
-        })();
-        this.loads.set(key, load);
-        load.catch(() => {
-            this.loads.delete(key);
         });
-        return load;
     }
     /*  ==== task plans ====  */
     async taskList(prjId) {
@@ -606,30 +544,6 @@ class GiteaTaskStoragePlugin {
         throw new Error(`task "${oldId}" cannot be renamed to "${newId}", as task ids are Gitea issue numbers`);
     }
     /*  ==== change detection ====  */
-    /*  the change detection state of a project (starting at the opening time)  */
-    pollState(prjId) {
-        let state = this.polls.get(prjId);
-        if (state === undefined) {
-            state = { since: this.opened, seen: new Map() };
-            this.polls.set(prjId, state);
-        }
-        return state;
-    }
-    /*  poll all registered projects, never overlapping itself  */
-    async pollAll() {
-        if (this.polling)
-            return;
-        this.polling = true;
-        try {
-            for (const prjId of this.repos.keys())
-                await this.pollProject(prjId).catch((err) => {
-                    this.ctx.log("warning", `polling project "${prjId}" failed: ${err instanceof Error ? err.message : String(err)}`);
-                });
-        }
-        finally {
-            this.polling = false;
-        }
-    }
     /*  poll the issues of a project updated since the last poll (Gitea supports no
         conditional requests), and report the issues not seen at their update time yet:
         as added if created after the opening, else as updated (issues deleted on Gitea

package/dst/ase-task-store-plugin-github.js

@@ -60,18 +60,9 @@ const inRepo = (loc, issue) => {
     the attachments onto the issue comments (where "Group" and "After" fall back
     onto "ase:Group:<id>" resp. "ase:After:<ids>" labels on instances without
     sub-issues resp. issue dependencies)  */
-class GitHubTaskStoragePlugin {
-    ctx;
+class GitHubTaskStoragePlugin extends TaskIssues.IssueTaskStoragePlugin {
     name = "github";
-    url;
     gh;
-    repos = new Map();
-    poll;
-    listener = null;
-    timer = null;
-    polling = false;
-    opened = now();
-    polls = new Map();
     registry = new LRUCache({ max: 64, ttl: 60 * 1000 });
     latest = new Map();
     labels = new Map();
@@ -80,9 +71,9 @@ class GitHubTaskStoragePlugin {
     recent = new Map();
     loads = new LRUCache({ max: 256, ttl: 2 * 1000 });
     constructor(ctx) {
-        this.ctx = ctx;
+        super(ctx, "repositories", now);
         const options = ctx.options;
-        const token = options.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? "";
+        const token = options.token ?? (process.env.GITHUB_TOKEN || process.env.GH_TOKEN) ?? "";
         if (typeof token !== "string" || token === "")
             throw new Error("task store: plugin \"github\" requires the \"token\" option (or $GITHUB_TOKEN resp. $GH_TOKEN)");
         const url = options.url ?? "https://github.com";
@@ -131,7 +122,7 @@ class GitHubTaskStoragePlugin {
         /*  explain a denied access (but not an exceeded rate limit), as the
             GitHub message names neither the token source nor the missing permission  */
         const source = options.token !== undefined ? "the \"token\" option (resp. \"project.task.store.token\")" :
-            process.env.GITHUB_TOKEN !== undefined ? "$GITHUB_TOKEN" : "$GH_TOKEN";
+            process.env.GITHUB_TOKEN !== undefined && process.env.GITHUB_TOKEN !== "" ? "$GITHUB_TOKEN" : "$GH_TOKEN";
         this.gh.hook.error("request", (err, request) => {
             const status = statusOf(err);
             if ((status === 401 || status === 403) && !/rate limit/i.test(err.message)) {
@@ -144,27 +135,6 @@ class GitHubTaskStoragePlugin {
             throw err;
         });
     }
-    /*  the storage lifecycle: polling for changes while opened and observed
-        (without keeping the process alive)  */
-    async open() {
-        this.opened = now();
-        if (this.poll > 0 && this.listener !== null) {
-            this.timer = setInterval(() => {
-                this.pollAll().catch(() => { });
-            }, this.poll * 1000);
-            this.timer.unref();
-        }
-        this.ctx.log("debug", `opened ${this.repos.size} repositories on ${this.url} (polling every ${this.poll}s)`);
-    }
-    async close() {
-        if (this.timer !== null)
-            clearInterval(this.timer);
-        this.timer = null;
-    }
-    /*  observe the changes of the issues made outside of this plugin instance  */
-    watch(listener) {
-        this.listener = listener;
-    }
     /*  ==== project registry ====  */
     /*  the repository of a project  */
     repo(prjId) {
@@ -222,15 +192,6 @@ class GitHubTaskStoragePlugin {
             throw err;
         }
     }
-    async projectList() {
-        const out = [];
-        for (const prjId of this.repos.keys()) {
-            const entry = await this.projectGet(prjId);
-            if (entry !== null)
-                out.push(entry);
-        }
-        return out;
-    }
     /*  get a project, with the highest issue number as the sequence number high-water
         mark, so the next allocated task id is the one of the next created issue  */
     async projectGet(prjId) {
@@ -501,11 +462,7 @@ class GitHubTaskStoragePlugin {
         own write or detected change of the issue), as e.g. the boards load the plan
         and its attachments in separate operations  */
     load(prjId, loc, n) {
-        const key = `${prjId}#${n}`;
-        const cached = this.loads.get(key);
-        if (cached !== undefined)
-            return cached;
-        const load = (async () => {
+        return TaskIssues.memoize(this.loads, `${prjId}#${n}`, async () => {
             const [issue, comments] = await Promise.all([
                 this.fetch(loc, n),
                 n === 0 ? [] : found(this.gh.paginate(this.gh.rest.issues.listComments, { ...loc, issue_number: n, per_page: 100 }))
@@ -513,12 +470,7 @@ class GitHubTaskStoragePlugin {
             if (issue === null)
                 return null;
             return { issue, after: await this.blockers(loc, issue), comments: comments ?? [] };
-        })();
-        this.loads.set(key, load);
-        load.catch(() => {
-            this.loads.delete(key);
         });
-        return load;
     }
     /*  ==== task plans ====  */
     async taskList(prjId) {
@@ -618,30 +570,6 @@ class GitHubTaskStoragePlugin {
         throw new Error(`task "${oldId}" cannot be renamed to "${newId}", as task ids are GitHub issue numbers`);
     }
     /*  ==== change detection ====  */
-    /*  the change detection state of a project (starting at the opening time)  */
-    pollState(prjId) {
-        let state = this.polls.get(prjId);
-        if (state === undefined) {
-            state = { since: this.opened, seen: new Map() };
-            this.polls.set(prjId, state);
-        }
-        return state;
-    }
-    /*  poll all registered projects, never overlapping itself  */
-    async pollAll() {
-        if (this.polling)
-            return;
-        this.polling = true;
-        try {
-            for (const prjId of this.repos.keys())
-                await this.pollProject(prjId).catch((err) => {
-                    this.ctx.log("warning", `polling project "${prjId}" failed: ${err instanceof Error ? err.message : String(err)}`);
-                });
-        }
-        finally {
-            this.polling = false;
-        }
-    }
     /*  poll the issues of a project updated since the last poll, conditionally
         via the entity tag of the last poll (a "304" answer is free of rate limit),
         and report the issues not seen at their update time yet: as added if created