@netnodeag/kraftwerk 0.80.0 → 0.82.0

package/dist/cli/temp.js

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import { cleanTemp, listTemp, SWEEP_AFTER_MS } from "../core/temp.js";
+import { fmtAgo } from "./workspaces.js";
+import { initContext as prepare } from "./routines.js";
+/**
+ * `kraftwerk temp` — the sessions' scratch folders under kraftwerk-data/temp
+ * (one per chat session; TMPDIR of the agent process). Nothing in there is
+ * a deliverable: a clean deletes for good, no trash.
+ *
+ *   kraftwerk temp                          list: session, files, size, last change
+ *   kraftwerk temp clean                    remove folders idle for a week
+ *   kraftwerk temp clean --older-than <d>   … idle for <d> days
+ *   kraftwerk temp clean --all              remove every folder
+ */
+const fmtBytes = (n) => n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} KB` : n < 1024 ** 3 ? `${(n / 1024 ** 2).toFixed(1)} MB` : `${(n / 1024 ** 3).toFixed(2)} GB`;
+export function registerTempCommands(program) {
+    const temp = program.command("temp").description("The sessions' scratch folders: list, clean");
+    temp
+        .command("list", { isDefault: true })
+        .description("List the scratch folders, newest first")
+        .option("--json", "Machine-readable output")
+        .action(async (opts) => {
+        await prepare();
+        const view = await listTemp();
+        if (opts.json) {
+            console.log(JSON.stringify(view, null, 2));
+            return;
+        }
+        if (view.entries.length === 0) {
+            console.log(chalk.dim("No scratch folders."));
+            console.log(chalk.dim(view.root));
+            return;
+        }
+        const table = new Table({ head: ["session", "files", "size", "last change"].map((h) => chalk.bold(h)) });
+        for (const e of view.entries)
+            table.push([chalk.cyan(e.id), String(e.files), fmtBytes(e.bytes), chalk.dim(fmtAgo(e.modifiedAt))]);
+        console.log(table.toString());
+        console.log(chalk.dim(`${view.root} — ${fmtBytes(view.bytes)} in ${view.entries.length} folder${view.entries.length === 1 ? "" : "s"}`));
+    });
+    temp
+        .command("clean")
+        .description(`Remove scratch folders idle for ${SWEEP_AFTER_MS / 86_400_000} days (for good — nothing there is a deliverable)`)
+        .option("--older-than <days>", "Remove folders idle for this many days instead")
+        .option("--all", "Remove every folder, whatever its age")
+        .option("--json", "Machine-readable output")
+        .action(async (opts) => {
+        await prepare();
+        const days = opts.olderThan === undefined ? undefined : Number(opts.olderThan);
+        if (days !== undefined && (!Number.isFinite(days) || days < 0)) {
+            console.error(chalk.red(`--older-than wants a number of days, not "${opts.olderThan}"`));
+            process.exit(2);
+        }
+        const gone = await cleanTemp({ all: opts.all, ...(days === undefined ? {} : { olderThanMs: days * 86_400_000 }) });
+        const bytes = gone.reduce((n, e) => n + e.bytes, 0);
+        if (opts.json) {
+            console.log(JSON.stringify({ removed: gone.map((e) => e.id), bytes }, null, 2));
+            return;
+        }
+        console.log(`${chalk.green("✔")} removed ${gone.length} folder${gone.length === 1 ? "" : "s"} (${fmtBytes(bytes)})`);
+    });
+}

package/dist/client/routes.d.ts

@@ -20,6 +20,12 @@ export declare const ROUTES: {
     readonly "agents.skills": readonly ["GET", "/api/agents/:slug/skills"];
     readonly "agents.status": readonly ["GET", "/api/agent-status"];
     readonly "attention.list": readonly ["GET", "/api/attention"];
+    readonly "boards.create": readonly ["POST", "/api/boards"];
+    readonly "boards.delete": readonly ["DELETE", "/api/boards/:board"];
+    readonly "boards.ensure": readonly ["POST", "/api/boards/default"];
+    readonly "boards.get": readonly ["GET", "/api/boards/:board"];
+    readonly "boards.list": readonly ["GET", "/api/boards"];
+    readonly "boards.save": readonly ["PUT", "/api/boards/:board"];
     readonly "channels.create": readonly ["POST", "/api/channels"];
     readonly "channels.delete": readonly ["DELETE", "/api/channels/:slug"];
     readonly "channels.fromChat": readonly ["POST", "/api/channels/from-chat"];
@@ -136,6 +142,16 @@ export declare const ROUTES: {
     readonly "settings.save": readonly ["PUT", "/api/settings"];
     readonly "skills.get": readonly ["GET", "/api/skills/:name"];
     readonly "skills.list": readonly ["GET", "/api/skills"];
+    readonly "tasks.assign": readonly ["POST", "/api/boards/:board/tasks/:task/assign"];
+    readonly "tasks.create": readonly ["POST", "/api/boards/:board/tasks"];
+    readonly "tasks.delete": readonly ["DELETE", "/api/boards/:board/tasks/:task"];
+    readonly "tasks.get": readonly ["GET", "/api/boards/:board/tasks/:task"];
+    readonly "tasks.log": readonly ["POST", "/api/boards/:board/tasks/:task/log"];
+    readonly "tasks.move": readonly ["POST", "/api/boards/:board/tasks/:task/move"];
+    readonly "tasks.pick": readonly ["POST", "/api/boards/:board/pick"];
+    readonly "tasks.save": readonly ["PUT", "/api/boards/:board/tasks/:task"];
+    readonly "temp.clean": readonly ["DELETE", "/api/temp"];
+    readonly "temp.list": readonly ["GET", "/api/temp"];
     readonly "trash.empty": readonly ["DELETE", "/api/trash"];
     readonly "trash.list": readonly ["GET", "/api/trash"];
     readonly "trash.purge": readonly ["POST", "/api/trash/purge"];

package/dist/client/routes.js

@@ -21,6 +21,12 @@ export const ROUTES = {
     "agents.skills": ["GET", "/api/agents/:slug/skills"],
     "agents.status": ["GET", "/api/agent-status"],
     "attention.list": ["GET", "/api/attention"],
+    "boards.create": ["POST", "/api/boards"],
+    "boards.delete": ["DELETE", "/api/boards/:board"],
+    "boards.ensure": ["POST", "/api/boards/default"],
+    "boards.get": ["GET", "/api/boards/:board"],
+    "boards.list": ["GET", "/api/boards"],
+    "boards.save": ["PUT", "/api/boards/:board"],
     "channels.create": ["POST", "/api/channels"],
     "channels.delete": ["DELETE", "/api/channels/:slug"],
     "channels.fromChat": ["POST", "/api/channels/from-chat"],
@@ -137,6 +143,16 @@ export const ROUTES = {
     "settings.save": ["PUT", "/api/settings"],
     "skills.get": ["GET", "/api/skills/:name"],
     "skills.list": ["GET", "/api/skills"],
+    "tasks.assign": ["POST", "/api/boards/:board/tasks/:task/assign"],
+    "tasks.create": ["POST", "/api/boards/:board/tasks"],
+    "tasks.delete": ["DELETE", "/api/boards/:board/tasks/:task"],
+    "tasks.get": ["GET", "/api/boards/:board/tasks/:task"],
+    "tasks.log": ["POST", "/api/boards/:board/tasks/:task/log"],
+    "tasks.move": ["POST", "/api/boards/:board/tasks/:task/move"],
+    "tasks.pick": ["POST", "/api/boards/:board/pick"],
+    "tasks.save": ["PUT", "/api/boards/:board/tasks/:task"],
+    "temp.clean": ["DELETE", "/api/temp"],
+    "temp.list": ["GET", "/api/temp"],
     "trash.empty": ["DELETE", "/api/trash"],
     "trash.list": ["GET", "/api/trash"],
     "trash.purge": ["POST", "/api/trash/purge"],

package/dist/config.d.ts

@@ -135,6 +135,23 @@ export interface EntitiesConfig {
     root?: string;
 }
 export declare const ENTITY_KINDS: readonly ["contacts", "places", "events"];
+/**
+ * Boards: the work as columns of tasks, one folder per task (task.md, log.md,
+ * files) under a board folder — inside a project (projects/<p>/boards/) or
+ * at the workspace level under the boards root. Part of the workspace and
+ * synced by the workspace git; agents are woken by events on this machine.
+ */
+export interface BoardsConfig {
+    /** false keeps the block but turns the feature off. Default: true. */
+    enabled?: boolean;
+    /** Where the workspace boards live, relative to the project root. Default: kraftwerk-data/boards */
+    root?: string;
+    /** Default columns for boards that name none (slugs or {slug, label, limit, done, review}). Default: draft, todo, progress, review, done. */
+    columns?: unknown;
+}
+export declare const BOARDS_DEFAULT_ROOT = "kraftwerk-data/boards";
+/** Absolute workspace boards root when the feature is on, undefined otherwise. */
+export declare function boardsRootFor(project: ResolvedWorkspace): string | undefined;
 export type EntityKind = (typeof ENTITY_KINDS)[number];
 /** Where a kind's files live when its `root` is not set. */
 export declare const entityDefaultRoot: (kind: EntityKind) => string;
@@ -218,6 +235,8 @@ export interface WorkspaceConfig {
     places?: EntitiesConfig;
     /** Events: dated entries (one-off), one Markdown file each. Absent = off. */
     events?: EntitiesConfig;
+    /** Boards: tasks as folders in columns, per project and workspace-wide. Absent = off. */
+    boards?: BoardsConfig;
     /** The machine's cloud record lists this workspace. Absent = listed; `enabled: false` leaves it out. */
     cloud?: CloudConfig;
 }

package/dist/config.js

@@ -97,6 +97,14 @@ export function projectsRootFor(project) {
     return path.resolve(project.root, p.root ?? PROJECTS_DEFAULT_ROOT);
 }
 export const ENTITY_KINDS = ["contacts", "places", "events"];
+export const BOARDS_DEFAULT_ROOT = "kraftwerk-data/boards";
+/** Absolute workspace boards root when the feature is on, undefined otherwise. */
+export function boardsRootFor(project) {
+    const b = project.config.boards;
+    if (!b || b.enabled === false)
+        return undefined;
+    return path.resolve(project.root, b.root ?? BOARDS_DEFAULT_ROOT);
+}
 /** Where a kind's files live when its `root` is not set. */
 export const entityDefaultRoot = (kind) => `kraftwerk-data/${kind}`;
 /** Absolute root of a kind when its feature is on, undefined otherwise. */
@@ -241,7 +249,7 @@ export async function addWorkspaceId(configPath) {
     await writeFile(configPath, out);
     return id;
 }
-const KNOWN_KEYS = ["id", "name", "slug", "icon", "color", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git", "repos", "vibeables", "projects", "contacts", "places", "events", "cloud"];
+const KNOWN_KEYS = ["id", "name", "slug", "icon", "color", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git", "repos", "vibeables", "projects", "contacts", "places", "events", "boards", "cloud"];
 /**
  * Keys an older kraftwerk understood and this one ignores, so the files
  * that still carry them keep loading: `public:` and `tunnel:` (the
@@ -313,6 +321,11 @@ async function loadConfig(configPath) {
                 config[key] = {};
             validateRootBlock(configPath, key, config[key]);
         }
+        else if (key === "boards") {
+            if (config[key] === null)
+                config[key] = {};
+            validateBoards(configPath, config[key]);
+        }
         else if (key === "cloud") {
             if (config[key] === null)
                 config[key] = {};
@@ -418,6 +431,16 @@ function validateGit(configPath, value) {
  * anything outside it — it is what remove/delete operate under, and what
  * the workspace git may stage.
  */
+/** `boards`: the root block plus `columns`, which core/boards.ts reads (a bad list falls back to the defaults there). */
+function validateBoards(configPath, value) {
+    const file = path.basename(configPath);
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error(`${file}: boards must be a mapping (enabled, root, columns)`);
+    const { columns, ...rest } = value;
+    if (columns !== undefined && columns !== null && !Array.isArray(columns))
+        throw new Error(`${file}: boards.columns must be a list of columns`);
+    validateRootBlock(configPath, "boards", rest);
+}
 function validateRootBlock(configPath, block, value) {
     const file = path.basename(configPath);
     if (typeof value !== "object" || value === null || Array.isArray(value)) {

package/dist/core/attention.d.ts

@@ -33,8 +33,8 @@ export interface AttentionOwner {
 export interface AttentionItem {
     /** The request id (live requests) or the notification id (failures). */
     id: string;
-    /** runner: routines without a runner, or naming a retired identity of this machine (see routines.ts). */
-    kind: "approval" | "question" | "failed" | "runner";
+    /** runner: routines without a runner, or naming a retired identity of this machine (see routines.ts); review: a task waits in a review column (boards.ts). */
+    kind: "approval" | "question" | "failed" | "runner" | "review";
     /** What is asked, or what went wrong. */
     title: string;
     /** The session it sits in. */

package/dist/core/attention.js

@@ -1,14 +1,16 @@
 import { listAgents } from "./agents.js";
+import { getBoard, listAllBoards } from "./boards.js";
 import { waitingRequests } from "./chat/sessions.js";
 import { chatHref, listNotifications } from "./notifications.js";
 import { listProjects } from "./projects.js";
 import { runnerFindings } from "./routines.js";
 export async function listAttention() {
-    const [agents, projects, notes, runners] = await Promise.all([
+    const [agents, projects, notes, runners, boards] = await Promise.all([
         listAgents().catch(() => []),
         listProjects().catch(() => ({ projects: [] })),
         listNotifications().catch(() => ({ items: [] })),
         runnerFindings().catch(() => ({ unassigned: [], retired: [] })),
+        listAllBoards().catch(() => []),
     ]);
     const agentOf = (slug) => {
         const a = agents.find((x) => x.slug === slug);
@@ -101,6 +103,24 @@ export async function listAttention() {
             routines: these,
         });
     }
-    const items = [...waiting, ...failed, ...runner].sort((a, b) => a.since.localeCompare(b.since));
+    // Tasks in a review column: the agents are done, a human decides. One item per task, placed in its project (workspace boards: general).
+    const review = [];
+    for (const b of boards) {
+        const detail = await getBoard(b).catch(() => null);
+        if (!detail)
+            continue;
+        const reviewCols = new Set(detail.columns.filter((c) => c.review).map((c) => c.slug));
+        for (const t of detail.items.filter((t) => reviewCols.has(t.status))) {
+            review.push({
+                id: `review:${t.ref}`,
+                kind: "review",
+                title: `${t.number} ${t.title} waits for your review${t.lastLog ? ` — ${t.lastLog}` : ""}`,
+                href: b.project ? `/projects/${b.project}/boards/${b.board}/${t.slug}` : `/boards/${b.board}/${t.slug}`,
+                since: t.updatedAt ?? new Date(0).toISOString(),
+                owner: b.project ? { project: projectOf(b.project) } : { general: true },
+            });
+        }
+    }
+    const items = [...waiting, ...failed, ...runner, ...review].sort((a, b) => a.since.localeCompare(b.since));
     return { items };
 }

package/dist/core/board-wake.d.ts

@@ -0,0 +1,21 @@
+/** A chat on the task page: the agent's task session (scope.task) or a chat tagged with the task (meta.task, "work on this"). */
+export interface TaskSession {
+    id: string;
+    /** The agent slug of a task session; "claude" | "codex" | "pi" for a plain chat tagged with the task. */
+    agent: string;
+    /** The agent's display name and emoji when it is one of the workspace's agents. */
+    name?: string;
+    emoji?: string;
+    title: string;
+    updatedAt: string;
+    busy: boolean;
+    /** The chat's route in the UI (#/agents/<slug>/chat/<id>, #/projects/<p>/chat/<id>, …). */
+    href: string;
+}
+/** The sessions that worked on a task, newest first: what the task page links the log's actors to. */
+export declare function taskSessions(ref: string): Promise<TaskSession[]>;
+/** Consume what was appended since the last run. Serialised: a run that overlaps is queued, never doubled. */
+export declare function consumeTaskEvents(): Promise<number>;
+/** Start consuming the current workspace's task events: on every change signal, on file changes, and every FALLBACK_MS anyway. */
+export declare function startBoardWake(): void;
+export declare function stopBoardWake(): void;

package/dist/core/board-wake.js

@@ -0,0 +1,221 @@
+import { promises as fs, watch } from "node:fs";
+import path from "node:path";
+import { getAgent, listAgents } from "./agents.js";
+import { EVENTS_FILE } from "./boards.js";
+import { onChanged } from "./changes.js";
+import { createChat, listChats, postMessage } from "./chat/sessions.js";
+import { getOutputDir } from "./context.js";
+import { chatHref, dismissKey, pushNotification } from "./notifications.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
+/**
+ * Waking agents for their tasks. boards.ts appends a TaskEvent line to
+ * <output>/boards/events.jsonl whenever a task with an agent as assignee
+ * sits in a work column after a change (created there, moved there,
+ * assigned); this module, started by the server for every open workspace,
+ * consumes the file: for each event it opens a session for the agent with
+ * the task as its scope (ChatScope.task → the task block in its context,
+ * unattended like a routine run) and posts why it was woken — or, when the
+ * agent already has a live session for that task, posts into that one.
+ *
+ * The file is read past a remembered offset (<output>/boards/events.offset),
+ * so every line is acted on once; it is rotated when it grows large. Writers
+ * append whole lines (O_APPEND), so a half-written line never appears.
+ */
+const STATE_FILE = "boards/events.offset";
+const ROTATE_OVER = 256 * 1024;
+const FALLBACK_MS = 20_000;
+const consumer = perWorkspace(() => ({
+    timer: null,
+    watcher: null,
+    unsubscribe: null,
+    running: false,
+    again: false,
+}));
+const eventsFile = () => path.join(getOutputDir(), EVENTS_FILE);
+const offsetFile = () => path.join(getOutputDir(), STATE_FILE);
+async function readOffset() {
+    const n = Number(await fs.readFile(offsetFile(), "utf8").catch(() => "0"));
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+/** Lines appended since the offset; the new offset. */
+async function readNew() {
+    const file = eventsFile();
+    const st = await fs.stat(file).catch(() => null);
+    if (!st)
+        return { events: [], offset: 0, size: 0 };
+    let offset = await readOffset();
+    if (offset > st.size)
+        offset = 0; // the file was rotated or replaced
+    if (offset === st.size)
+        return { events: [], offset, size: st.size };
+    const fh = await fs.open(file, "r");
+    try {
+        const buf = Buffer.alloc(st.size - offset);
+        await fh.read(buf, 0, buf.length, offset);
+        const text = buf.toString("utf8");
+        const complete = text.lastIndexOf("\n");
+        if (complete < 0)
+            return { events: [], offset, size: st.size };
+        const events = [];
+        for (const line of text.slice(0, complete).split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                /* a broken line is skipped, not retried forever */
+            }
+        }
+        return { events, offset: offset + complete + 1, size: st.size };
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** Keep the file small: once everything is consumed and it is big, start over (a writer racing the rename lands in the new file). */
+async function rotate(offset, size) {
+    if (size < ROTATE_OVER || offset < size)
+        return;
+    await fs.rename(eventsFile(), `${eventsFile()}.old`).catch(() => { });
+    await fs.rm(`${eventsFile()}.old`, { force: true }).catch(() => { });
+    await fs.writeFile(offsetFile(), "0");
+}
+/** The message the agent gets: why it was woken, in one paragraph; the task itself is in its context block. */
+function wakeMessage(ev, resumed) {
+    const who = ev.actor.replace(/^human:/, "");
+    const why = ev.reason === "created"
+        ? `Task ${ev.task} ("${ev.title}") was created for you by ${who}`
+        : ev.reason === "assigned"
+            ? `Task ${ev.task} ("${ev.title}") was handed to you by ${who}`
+            : `Task ${ev.task} ("${ev.title}") was moved to ${ev.status} for you by ${who}`;
+    return (`${why}${ev.message ? `: ${ev.message}` : "."}\n` +
+        (resumed
+            ? `Continue with it: read the task's log for what changed (\`npx kraftwerk tasks show ${ev.task} ${cliFlags(ev)}\`).`
+            : `It is in ${ev.status}. Read the task block in your context (task.md, files, log), move it to the work column when you start, log what you do, and hand it to review when done.`));
+}
+const cliFlags = (ev) => (ev.project ? `--project ${ev.project} --board ${ev.board}` : `--board ${ev.board}`);
+const taskOf = (c) => c.task ?? (c.scope.kind === "agent" ? c.scope.task : undefined);
+/** The sessions that worked on a task, newest first: what the task page links the log's actors to. */
+export async function taskSessions(ref) {
+    const [chats, agents] = await Promise.all([listChats(), listAgents().catch(() => [])]);
+    return chats
+        .filter((c) => taskOf(c) === ref)
+        .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1))
+        .map((c) => {
+        const slug = c.scope.kind === "agent" ? c.scope.slug : c.agent;
+        const def = agents.find((a) => a.slug === slug);
+        return { id: c.id, agent: slug, ...(def ? { name: def.name, emoji: def.emoji } : {}), title: c.title, updatedAt: c.updatedAt, busy: c.busy, href: chatHref(c) };
+    });
+}
+/** One event: post into the agent's live session for this task, or open one. */
+async function wake(ev) {
+    const def = await getAgent(ev.agent);
+    if (!def)
+        throw new Error(`agent "${ev.agent}" not found`);
+    const existing = (await listChats()).find((c) => c.scope.kind === "agent" && c.scope.slug === ev.agent && c.scope.task === ev.ref);
+    // Already on it (a turn is running in its session for this task): the agent reads the log when it looks; no second session.
+    if (existing?.busy)
+        return;
+    const meta = existing ??
+        (await createChat({
+            agent: def.harness,
+            scope: { kind: "agent", slug: ev.agent, task: ev.ref },
+            title: `📋 ${ev.task}`,
+            ...(ev.project ? { project: ev.project } : {}),
+        }));
+    const { error } = await postMessage(meta.id, wakeMessage(ev, !!existing));
+    if (error)
+        throw new Error(error);
+    await dismissKey(`task-wake:${ev.ref}`);
+    await pushNotification({
+        kind: "task_woken",
+        title: `📋 ${ev.task} → ${def.emoji} ${def.name}`,
+        body: ev.message ?? ev.title,
+        href: chatHref(meta),
+        key: `task-woken:${ev.ref}:${ev.agent}`,
+    }).catch(() => { });
+}
+/** Consume what was appended since the last run. Serialised: a run that overlaps is queued, never doubled. */
+export async function consumeTaskEvents() {
+    const c = consumer();
+    if (c.running) {
+        c.again = true;
+        return 0;
+    }
+    c.running = true;
+    let handled = 0;
+    try {
+        const { events, offset, size } = await readNew();
+        if (events.length) {
+            // The offset moves first: an event that keeps failing must not be retried on every tick.
+            await fs.mkdir(path.dirname(offsetFile()), { recursive: true });
+            await fs.writeFile(offsetFile(), String(offset));
+            // The same task for the same agent twice in one batch (assign, then move): the last reason wins.
+            const latest = new Map();
+            for (const ev of events)
+                latest.set(`${ev.ref}:${ev.agent}`, ev);
+            for (const ev of latest.values()) {
+                try {
+                    await wake(ev);
+                    handled++;
+                }
+                catch (err) {
+                    await pushNotification({
+                        kind: "task_wake_failed",
+                        title: `📋 ${ev.task}: ${ev.agent} could not be started`,
+                        body: err.message,
+                        href: ev.project ? `/projects/${ev.project}/boards/${ev.board}/${ev.task}` : `/boards/${ev.board}/${ev.task}`,
+                        key: `task-wake:${ev.ref}`,
+                    }).catch(() => { });
+                }
+            }
+        }
+        await rotate(offset, size);
+    }
+    finally {
+        c.running = false;
+        if (c.again) {
+            c.again = false;
+            void consumeTaskEvents().catch(() => { });
+        }
+    }
+    return handled;
+}
+/** Start consuming the current workspace's task events: on every change signal, on file changes, and every FALLBACK_MS anyway. */
+export function startBoardWake() {
+    const c = consumer();
+    if (c.timer)
+        return;
+    const kick = () => {
+        if (!workspaceOpen())
+            return;
+        void consumeTaskEvents().catch(() => { });
+    };
+    c.timer = setInterval(kick, FALLBACK_MS);
+    c.timer.unref?.();
+    c.unsubscribe = onChanged(kick);
+    const dir = path.dirname(eventsFile());
+    void fs.mkdir(dir, { recursive: true }).then(() => {
+        if (!c.timer || c.watcher)
+            return;
+        try {
+            c.watcher = watch(dir, { persistent: false }, kick);
+            c.watcher.on("error", () => { });
+        }
+        catch {
+            /* no watcher: the interval still runs */
+        }
+    });
+    kick();
+}
+export function stopBoardWake() {
+    const c = consumer();
+    if (c.timer)
+        clearInterval(c.timer);
+    c.timer = null;
+    c.unsubscribe?.();
+    c.unsubscribe = null;
+    c.watcher?.close();
+    c.watcher = null;
+}