@luuthuong/devboard 0.0.0-stage → 1.0.1

package/server-dist/server/integrations.js

@@ -0,0 +1,292 @@
+// Small adapters: context usage, statusline installer, Pushover, image storage,
+// card merge rules. Ports context_usage.rs, statusline_installer.rs,
+// pushover.rs, images.rs and merge_ops.rs.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { devboardDataDir, ksuid, writeFileAtomic } from "./util.js";
+/** Percentage-based when available (lifetime IO sum stays high after /compact). */
+export function currentContextTokens(u) {
+    if (u.contextWindowSize > 0 && u.usedPercentage > 0) {
+        return Math.round((u.contextWindowSize * u.usedPercentage) / 100);
+    }
+    return u.totalInputTokens + u.totalOutputTokens;
+}
+/** `null` = no statusline JSON yet (treat as unknown, never as zero). */
+export function readContextUsage(sessionId, base) {
+    const file = path.join(base ?? path.join(devboardDataDir(), "context"), `${sessionId}.json`);
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Latest snapshot for every session that has one, keyed by session id. */
+export function readAllContextUsage(base) {
+    const dir = base ?? path.join(devboardDataDir(), "context");
+    const out = {};
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return out;
+    }
+    for (const f of files) {
+        if (!f.endsWith(".json") || f.startsWith("."))
+            continue;
+        const id = f.slice(0, -".json".length);
+        const u = readContextUsage(id, dir);
+        if (!u)
+            continue;
+        out[id] = {
+            usedPercentage: u.usedPercentage,
+            tokens: currentContextTokens(u),
+            contextWindowSize: u.contextWindowSize,
+            inputTokens: u.totalInputTokens,
+            outputTokens: u.totalOutputTokens,
+            costUsd: u.totalCostUsd ?? 0,
+            model: u.model ?? "",
+        };
+    }
+    return out;
+}
+// ── Statusline installer ─────────────────────────────────────────────────────
+const STATUSLINE_KEY = "statusLine";
+const claudeSettingsPath = () => path.join(os.homedir(), ".claude", "settings.json");
+/** Self-contained statusline script. It runs on the same Node as the server, so it
+ *  needs neither `devboard` on PATH nor a built CLI. Snapshots land in ./context
+ *  next to the script, which is where `readContextUsage` looks. */
+const STATUSLINE_SCRIPT = `import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+let raw = "";
+for await (const chunk of process.stdin) raw += chunk;
+try {
+  const input = JSON.parse(raw);
+  const id = input?.session_id;
+  if (typeof id === "string" && /^[\\w-]+$/.test(id)) {
+    const cw = input.context_window ?? {};
+    const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+    const dir = path.join(path.dirname(fileURLToPath(import.meta.url)), "context");
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, "." + id + ".tmp");
+    fs.writeFileSync(
+      tmp,
+      JSON.stringify({
+        usedPercentage: num(cw.used_percentage),
+        contextWindowSize: num(cw.context_window_size),
+        totalInputTokens: num(cw.total_input_tokens),
+        totalOutputTokens: num(cw.total_output_tokens),
+        totalCostUsd: num(input.cost?.total_cost_usd),
+        model: typeof input.model?.display_name === "string" ? input.model.display_name : "",
+      })
+    );
+    fs.renameSync(tmp, path.join(dir, id + ".json"));
+    const pct = num(cw.used_percentage);
+    if (pct > 0) process.stdout.write("ctx " + Math.round(pct) + "%");
+  }
+} catch {
+  // A statusline must never break the Claude session.
+}
+`;
+const statuslineScriptPath = () => path.join(devboardDataDir(), "statusline.mjs");
+/** Forward slashes survive both cmd and the bash Claude Code may run the command in. */
+const slash = (p) => p.replace(/\\/g, "/");
+function statuslineCommand() {
+    return `"${slash(process.execPath)}" "${slash(statuslineScriptPath())}"`;
+}
+async function readSettingsJson(p) {
+    let text;
+    try {
+        text = await fs.promises.readFile(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+    if (!text.trim())
+        return null;
+    const v = JSON.parse(text);
+    if (typeof v !== "object" || v === null || Array.isArray(v)) {
+        // Bail rather than clobber a hand-edited oddball.
+        throw new Error("~/.claude/settings.json is not a JSON object");
+    }
+    return v;
+}
+export async function installStatusline() {
+    const p = claudeSettingsPath();
+    const root = (await readSettingsJson(p)) ?? {};
+    await writeFileAtomic(statuslineScriptPath(), STATUSLINE_SCRIPT);
+    root[STATUSLINE_KEY] = { type: "command", command: statuslineCommand(), padding: 0 };
+    await writeFileAtomic(p, JSON.stringify(root, null, 2));
+}
+export async function uninstallStatusline() {
+    const p = claudeSettingsPath();
+    const root = await readSettingsJson(p);
+    if (!root || !(STATUSLINE_KEY in root))
+        return;
+    delete root[STATUSLINE_KEY];
+    await writeFileAtomic(p, JSON.stringify(root, null, 2));
+}
+export async function statuslineInstalled() {
+    try {
+        const root = await readSettingsJson(claudeSettingsPath());
+        const cmd = root?.[STATUSLINE_KEY]?.command;
+        return (typeof cmd === "string" &&
+            (cmd.includes("statusline.mjs") || (cmd.includes("devboard") && cmd.includes("statusline"))));
+    }
+    catch {
+        return false;
+    }
+}
+// ── Pushover ─────────────────────────────────────────────────────────────────
+export async function pushoverSend(token, userKey, title, message, cardId) {
+    if (!token || !userKey)
+        throw new Error("pushover token/user key not configured");
+    const form = new URLSearchParams({ token, user: userKey, title, message, html: "1" });
+    if (cardId) {
+        form.set("url", `devboard://card/${cardId}`);
+        form.set("url_title", "Open in DevBoard");
+    }
+    const resp = await fetch("https://api.pushover.net/1/messages.json", {
+        method: "POST",
+        body: form,
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok)
+        throw new Error(`pushover responded ${resp.status}: ${await resp.text().catch(() => "")}`);
+}
+// ── Images ───────────────────────────────────────────────────────────────────
+function extensionFor(b) {
+    if (b.subarray(0, 4).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47])))
+        return "png";
+    if (b.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
+        return "jpg";
+    const head = b.subarray(0, 6).toString("latin1");
+    if (head === "GIF87a" || head === "GIF89a")
+        return "gif";
+    if (b.length > 11 &&
+        b.subarray(0, 4).toString("latin1") === "RIFF" &&
+        b.subarray(8, 12).toString("latin1") === "WEBP") {
+        return "webp";
+    }
+    return "png";
+}
+/** `<data_dir>/images/<ksuid>.<ext>`; returns the absolute path. */
+export async function saveImageBytes(bytes) {
+    const dir = path.join(devboardDataDir(), "images");
+    await fs.promises.mkdir(dir, { recursive: true });
+    const file = path.join(dir, `${ksuid("img")}.${extensionFor(bytes)}`);
+    await fs.promises.writeFile(file, bytes);
+    return file;
+}
+/** `<data_dir>/attachments/<ksuid>-<name>`; returns the absolute path. */
+export async function saveAttachmentBytes(bytes, name) {
+    const dir = path.join(devboardDataDir(), "attachments");
+    await fs.promises.mkdir(dir, { recursive: true });
+    const safe = path
+        .basename(name)
+        .replace(/[^\w.\- ]+/g, "_")
+        .slice(-120) || "file";
+    const file = path.join(dir, `${ksuid("att")}-${safe}`);
+    await fs.promises.writeFile(file, bytes);
+    return file;
+}
+/** Roots the file-serving endpoint may read from (images only). */
+export function allowedImageRoots() {
+    return [devboardDataDir()];
+}
+// ── Card merge ───────────────────────────────────────────────────────────────
+/** Reason a merge is blocked, or null when it can proceed. */
+export function mergeBlocked(source, target) {
+    if (source.id === target.id)
+        return "cannot merge a card into itself";
+    if (source.isLaunching === true || target.isLaunching === true) {
+        return "card is mid-launch — finish the launch before merging";
+    }
+    if (source.sessionLink && target.sessionLink) {
+        return "both cards have a Claude session — cannot collapse two live sessions";
+    }
+    if (source.worktreeLink && target.worktreeLink && source.worktreeLink.path !== target.worktreeLink.path) {
+        return `worktrees differ: ${source.worktreeLink.path} vs ${target.worktreeLink.path}`;
+    }
+    if (source.issueLink && target.issueLink && source.issueLink.number !== target.issueLink.number) {
+        return `issue numbers differ: #${source.issueLink.number} vs #${target.issueLink.number}`;
+    }
+    return null;
+}
+const later = (a, b) => a === undefined ? b : b === undefined ? a : Date.parse(b) > Date.parse(a) ? b : a;
+/** Fold `source` into `target` (nil-slot-wins). Callers must run mergeBlocked first. */
+export function mergeIntoTarget(source, target) {
+    target.name ??= source.name;
+    target.projectPath ??= source.projectPath;
+    if (target.promptBody === undefined) {
+        target.promptBody = source.promptBody;
+        // Image attachments travel with the prompt body.
+        target.promptImagePaths ??= source.promptImagePaths;
+    }
+    target.sessionLink ??= source.sessionLink;
+    target.worktreeLink ??= source.worktreeLink;
+    target.issueLink ??= source.issueLink;
+    if (!target.pinnedAt) {
+        target.pinnedAt = source.pinnedAt;
+        target.pinnedSortOrder = source.pinnedSortOrder;
+    }
+    // PR links: union by number, target wins on conflict.
+    const have = new Set(target.prLinks.map((p) => p.number));
+    for (const pr of source.prLinks) {
+        if (!have.has(pr.number)) {
+            target.prLinks.push(pr);
+            have.add(pr.number);
+        }
+    }
+    if (source.discoveredBranches) {
+        const merged = target.discoveredBranches ?? [];
+        for (const b of source.discoveredBranches)
+            if (!merged.includes(b))
+                merged.push(b);
+        target.discoveredBranches = merged;
+    }
+    target.lastActivity = later(target.lastActivity, source.lastActivity);
+    target.isRemote = target.isRemote || source.isRemote;
+    target.updatedAt = new Date().toISOString();
+    target.lastOpenedAt = later(target.lastOpenedAt, source.lastOpenedAt);
+    // Left alone on the target: id, column, createdAt, manualOverrides,
+    // manuallyArchived, source, isLaunching, queuedPrompts, sortOrder,
+    // assistantId, browserTabs.
+}
+// ── Card launcher ────────────────────────────────────────────────────────────
+/**
+ * cmd.exe ends a command at the first newline, so a multi-line prompt cannot ride on the
+ * `claude "<prompt>"` line. This runner takes the prompt as base64 (one safe token) and hands it
+ * to the command as a single argv entry, newlines and quotes intact.
+ *
+ *   node launch.mjs <promptBase64> <command> [args...]   →   <command> [args...] <prompt>
+ */
+const LAUNCH_SCRIPT = `// DevBoard card launcher. Generated; edits are overwritten.
+import { spawn } from "node:child_process";
+
+const [b64, exe, ...args] = process.argv.slice(2);
+if (!b64 || !exe) {
+  console.error("usage: node launch.mjs <promptBase64> <command> [args...]");
+  process.exit(2);
+}
+const prompt = Buffer.from(b64, "base64").toString("utf8");
+const child = spawn(exe, [...args, prompt], { stdio: "inherit" });
+child.on("error", (e) => {
+  console.error("Could not start " + exe + ": " + e.message);
+  process.exit(127);
+});
+child.on("exit", (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+`;
+const launchScriptPath = () => path.join(devboardDataDir(), "launch.mjs");
+/** Writes the launcher (idempotent) and returns the paths the UI needs to build its command line. */
+export async function ensureLauncher() {
+    const script = launchScriptPath();
+    const current = await fs.promises.readFile(script, "utf8").catch(() => null);
+    if (current !== LAUNCH_SCRIPT)
+        await writeFileAtomic(script, LAUNCH_SCRIPT);
+    return { node: process.execPath, script };
+}

package/server-dist/server/pollers.js

@@ -0,0 +1,332 @@
+// Background loops. Ports start_polling, start_pr_polling, start_issue_polling,
+// start_hook_polling, start_remote_polling and start_self_compact_polling from
+// lib.rs. Each loop is a self-rescheduling timer so a slow tick can't overlap
+// itself.
+import { notifyUser } from "./context.js";
+import { emit } from "./events.js";
+import { fetchIssues, fetchPrs, fetchUnresolvedThreads } from "./git.js";
+import { settleIntents } from "./harness/intents.js";
+import { HookEventStore, installIfNeeded } from "./hooks.js";
+import { currentContextTokens, readContextUsage } from "./integrations.js";
+import { RemoteStatusWatcher, syncStatus } from "./remote.js";
+import { reapSessions } from "./sessionReaper.js";
+import { readLastAssistantMessage } from "./transcripts.js";
+import { errorMessage, log } from "./util.js";
+/** Run `fn` forever, `delayMs()` after each completion. Errors are logged, never fatal. */
+function loop(name, initialDelayMs, delayMs, fn) {
+    const tick = async () => {
+        try {
+            await fn();
+        }
+        catch (e) {
+            log.warn(name, `tick failed: ${errorMessage(e)}`);
+        }
+        let next = 5_000;
+        try {
+            next = await delayMs();
+        }
+        catch {
+            // keep the default
+        }
+        setTimeout(tick, next).unref();
+    };
+    setTimeout(tick, initialDelayMs).unref();
+}
+// Skip the broadcast when nothing visible changed (relativeTime has minute
+// granularity, so the label still refreshes when it flips).
+let lastBoardSig = "";
+async function refreshAndBroadcast(ctx) {
+    const s = await ctx.settings.read().catch(() => null);
+    const projectPaths = (s?.projects ?? []).flatMap((pr) => [pr.path, pr.repoRoot].filter((x) => !!x));
+    await ctx.board.refresh(ctx.discovery, ctx.store, projectPaths);
+    const dto = ctx.board.toDto();
+    const sig = JSON.stringify(dto.cards);
+    if (sig === lastBoardSig)
+        return;
+    lastBoardSig = sig;
+    emit("board-updated", dto);
+}
+// ── Board (every 5 s) ────────────────────────────────────────────────────────
+function startBoardPolling(ctx) {
+    loop("poll", 5_000, () => 5_000, async () => {
+        try {
+            await refreshAndBroadcast(ctx);
+        }
+        catch (e) {
+            log.warn("poll", `board refresh failed: ${errorMessage(e)}`);
+            return;
+        }
+        // Cards whose agent just finished a turn → notify (browser + Pushover).
+        for (const card of ctx.board.drainNotificationCandidates()) {
+            const p = card.link.sessionLink?.sessionPath;
+            const body = (p ? await readLastAssistantMessage(p, 240) : null) ?? "Claude finished — your input is needed.";
+            await notifyUser(ctx, { title: card.displayTitle, body, threadId: card.id });
+        }
+    });
+}
+// ── PRs (every 60 s, offset 15 s) ────────────────────────────────────────────
+function startPrPolling(ctx) {
+    loop("pr-poll", 15_000, () => 60_000, async () => {
+        const links = await ctx.store.readLinks();
+        const projects = [
+            ...new Set(links.filter((l) => l.worktreeLink?.branch && l.projectPath).map((l) => l.projectPath)),
+        ];
+        // branch → PR info, gathered outside the store lock (network + gh forks).
+        const updates = [];
+        for (const project of projects) {
+            const prs = await fetchPrs(project).catch(() => []);
+            const threads = await fetchUnresolvedThreads(prs).catch(() => new Map());
+            for (const pr of prs)
+                updates.push({ project, pr, threads: threads.get(pr.number) });
+        }
+        let changed = false;
+        await ctx.store.update((current) => {
+            for (const { pr, threads } of updates) {
+                for (const link of current) {
+                    if (link.worktreeLink?.branch !== pr.headRef)
+                        continue;
+                    const prLink = {
+                        number: pr.number,
+                        url: pr.url,
+                        status: pr.state,
+                        title: pr.title,
+                        body: pr.body,
+                        approvalCount: pr.approvalCount,
+                        unresolvedThreads: threads,
+                        mergeStateStatus: pr.mergeStateStatus,
+                        reviewDecision: pr.reviewDecision,
+                        checkRuns: pr.checkRuns,
+                    };
+                    const i = link.prLinks.findIndex((p) => p.number === pr.number);
+                    if (i >= 0)
+                        link.prLinks[i] = prLink;
+                    else
+                        link.prLinks.push(prLink);
+                    changed = true;
+                }
+            }
+            return changed ? current : false;
+        });
+        if (changed)
+            await refreshAndBroadcast(ctx);
+    });
+}
+// ── GitHub issues (settings.github.pollIntervalSeconds, offset 10 s) ─────────
+function startIssuePolling(ctx) {
+    loop("issue-poll", 10_000, async () => ((await ctx.settings.read().catch(() => null))?.github.pollIntervalSeconds ?? 60) * 1000, async () => {
+        const settings = await ctx.settings.read();
+        const projectFilters = settings.projects
+            .map((p) => ({
+            repoRoot: p.repoRoot ?? p.path,
+            filter: p.githubFilter ?? settings.github.defaultFilter,
+        }))
+            .filter((pf) => pf.filter);
+        if (projectFilters.length === 0)
+            return;
+        const fetchedKeys = new Set();
+        const fetched = [];
+        for (const { repoRoot, filter } of projectFilters) {
+            for (const issue of await fetchIssues(repoRoot, filter).catch(() => [])) {
+                fetchedKeys.add(`${repoRoot}:${issue.number}`);
+                fetched.push({ repoRoot, issue });
+            }
+        }
+        const roots = new Set(projectFilters.map((pf) => pf.repoRoot));
+        let changed = false;
+        const existing = await ctx.store.readLinks();
+        for (const { repoRoot, issue } of fetched) {
+            const exists = existing.some((l) => l.issueLink?.number === issue.number && l.projectPath === repoRoot);
+            if (exists)
+                continue;
+            const prompt = settings.githubIssuePromptTemplate
+                .replaceAll("${number}", String(issue.number))
+                .replaceAll("${title}", issue.title)
+                .replaceAll("${body}", issue.body ?? "")
+                .replaceAll("${url}", issue.url);
+            await ctx.store.createIssueCard({
+                projectPath: repoRoot,
+                issueNumber: issue.number,
+                issueTitle: issue.title,
+                issueUrl: issue.url,
+                issueBody: issue.body,
+                promptBody: prompt,
+            });
+            changed = true;
+        }
+        // Drop backlog issue-cards whose issue no longer matches the filter.
+        await ctx.store.update((links) => {
+            const keep = (l) => {
+                if (l.source !== "github_issue" || l.column !== "backlog")
+                    return true;
+                if (!l.projectPath || !roots.has(l.projectPath) || !l.issueLink)
+                    return true;
+                return fetchedKeys.has(`${l.projectPath}:${l.issueLink.number}`);
+            };
+            const next = links.filter(keep);
+            if (next.length === links.length)
+                return false;
+            changed = true;
+            return next;
+        });
+        if (changed)
+            await refreshAndBroadcast(ctx);
+    });
+}
+// ── Hook events (every 1 s) ──────────────────────────────────────────────────
+function startHookPolling(ctx) {
+    void (async () => {
+        // Installed in the background so a slow WSL boot doesn't delay startup.
+        try {
+            if (!(await installIfNeeded()))
+                return; // intentionally skipped — no tail loop
+        }
+        catch (e) {
+            log.warn("hooks", `install failed: ${errorMessage(e)} — tail loop will still run`);
+        }
+        const store = new HookEventStore();
+        store.touch();
+        store.skipToTail(); // don't replay history from a previous run
+        loop("hooks", 1_000, () => 1_000, async () => {
+            let moved = false;
+            for (const ev of await store.readNewEvents()) {
+                log.debug("hooks", `event session=${ev.sessionId} name=${ev.eventName} type=${ev.notificationType ?? "-"} at=${ev.timestamp}`);
+                emit("hook-event", ev);
+                // A session that ends or compacts is a natural point to distill what it learned.
+                if ((ev.eventName === "SessionEnd" || ev.eventName === "PreCompact") && ev.transcriptPath) {
+                    void distill(ctx, { sessionId: ev.sessionId, transcriptPath: ev.transcriptPath });
+                }
+                if (ctx.board.applyHookEvent(ev.sessionId, ev.eventName, ev.notificationType, Date.parse(ev.timestamp))) {
+                    moved = true;
+                }
+            }
+            // Re-run the board now rather than waiting for the 5 s tick.
+            if (moved)
+                await refreshAndBroadcast(ctx).catch((e) => log.warn("hooks", `refresh failed: ${errorMessage(e)}`));
+        });
+    })();
+}
+// ── Remote status (every 5 s) ────────────────────────────────────────────────
+function startRemotePolling() {
+    const watcher = new RemoteStatusWatcher();
+    let last = null;
+    loop("remote", 5_000, () => 5_000, async () => {
+        const status = await syncStatus();
+        if (!last || last.kind !== status.kind || last.conflictCount !== status.conflictCount) {
+            emit("sync_status_event", status);
+            last = status;
+        }
+        for (const change of await watcher.poll())
+            emit("remote_status_changed", change);
+    });
+}
+// ── Self-compact guard ───────────────────────────────────────────────────────
+/** Queue a nudge for any session whose context crossed a rule's threshold. The
+ *  highest crossed threshold wins; the store dedupes repeats. */
+function startSelfCompactPolling(ctx) {
+    loop("self-compact", 1_000, async () => {
+        const s = await ctx.settings.read().catch(() => null);
+        return s ? Math.max(1, s.selfCompact?.pollIntervalSeconds ?? 30) * 1000 : 30_000;
+    }, async () => {
+        const s = await ctx.settings.read();
+        if (!s.selfCompact?.enabled)
+            return;
+        const rules = [...s.selfCompact.rules].sort((a, b) => b.thresholdTokens - a.thresholdTokens);
+        for (const link of await ctx.store.readLinks()) {
+            const sessionId = link.sessionLink?.sessionId;
+            if (!sessionId)
+                continue;
+            const usage = readContextUsage(sessionId);
+            if (!usage)
+                continue;
+            const used = currentContextTokens(usage);
+            const rule = rules.find((r) => used >= r.thresholdTokens);
+            if (rule)
+                await ctx.store.enqueueSelfCompactPrompt(link.id, rule.message, rule.thresholdTokens);
+        }
+    });
+}
+// ── Terminal session housekeeping (every 30 s) ───────────────────────────────
+function startSessionReaper(ctx) {
+    loop("sessions", 30_000, () => 30_000, () => reapSessions(ctx));
+}
+// ── Knowledge harness (every minute) ────────────────────────────────────────
+function distill(ctx, args) {
+    return ctx.harness.distillSession(args).then((added) => {
+        if (!added.length)
+            return;
+        emit("harness-updated", { proposals: added.length });
+        return notifyUser(ctx, {
+            title: added.length === 1 ? "Knowledge to review" : `${added.length} knowledge entries to review`,
+            body: added.length === 1 ? added[0].title : added.map((p) => p.title).join(" · "),
+            threadId: "knowledge-review",
+        });
+    }, (e) => log.warn("librarian", `distill failed: ${errorMessage(e)}`));
+}
+function startHarnessPolling(ctx) {
+    const distilledCards = new Set();
+    let lastSync = 0;
+    let lastMaintain = 0;
+    let packInstalled = false;
+    let doneSeeded = false;
+    loop("harness", 2_000, () => 60_000, async () => {
+        const s = await ctx.settings.read().catch(() => null);
+        const h = s?.harness;
+        const now = Date.now();
+        if (lastSync === 0) {
+            await ctx.harness.reload();
+            lastSync = now;
+        }
+        else if (now - lastSync >= (h?.pullIntervalMinutes ?? 10) * 60_000) {
+            lastSync = now;
+            if (await ctx.harness.sync())
+                emit("harness-updated", {});
+        }
+        if (!ctx.harness.configured) {
+            packInstalled = false;
+            return;
+        }
+        // Once per configuration (startup, or a repo set in Settings): skills, subagents, hook.
+        if (!packInstalled) {
+            packInstalled = true;
+            await ctx.harness.installPack().catch((e) => log.warn("harness", `pack install failed: ${errorMessage(e)}`));
+        }
+        // Cards that reach Done from now on: distill their session once. Cards already
+        // done when the harness starts are history, not new work, so they are skipped.
+        const links = await ctx.store.readLinks();
+        if (!doneSeeded) {
+            doneSeeded = true;
+            for (const l of links)
+                if (l.column === "done")
+                    distilledCards.add(l.id);
+        }
+        for (const l of links) {
+            if (l.column !== "done" || distilledCards.has(l.id))
+                continue;
+            distilledCards.add(l.id);
+            const sid = l.sessionLink?.sessionId;
+            const transcriptPath = l.sessionLink?.sessionPath;
+            if (sid && transcriptPath)
+                await distill(ctx, { sessionId: sid, transcriptPath, cardId: l.id });
+        }
+        const settled = await settleIntents({ store: ctx.store, intents: ctx.harness.intents });
+        if (settled.length)
+            emit("harness-updated", { intents: settled.length });
+        if (now - lastMaintain >= 24 * 3_600_000) {
+            lastMaintain = now;
+            const paths = (s?.projects ?? []).map((p) => p.repoRoot ?? p.path);
+            const report = await ctx.harness.maintain(paths);
+            if (report.stale.length)
+                log.info("harness", `${report.stale.length} entr(ies) may be outdated`);
+        }
+    });
+}
+export function startPollers(ctx) {
+    startHarnessPolling(ctx);
+    startBoardPolling(ctx);
+    startPrPolling(ctx);
+    startIssuePolling(ctx);
+    startHookPolling(ctx);
+    startRemotePolling();
+    startSelfCompactPolling(ctx);
+    startSessionReaper(ctx);
+}