parawatch 0.0.0-stage → 0.2.0

package/dist/core/ops.js

@@ -0,0 +1,415 @@
+import fs from "node:fs";
+import path from "node:path";
+import { appendEvent, eventsPath, homeDir, readCursor, readEvents, writeCursor } from "./store.js";
+import { fold, nextId } from "./state.js";
+import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
+export class UserError extends Error {
+}
+function cleanList(xs) {
+    const out = (xs ?? []).map((x) => x.trim()).filter(Boolean);
+    return out.length ? out : undefined;
+}
+function absPaths(xs) {
+    // attachments and things to open are kept as given when they look like URLs
+    return cleanList(xs)?.map((x) => (/^[a-z]+:\/\//i.test(x) ? x : path.resolve(x)));
+}
+export function addProject(name, paths) {
+    if (!/^[A-Za-z0-9._-]+$/.test(name))
+        throw new UserError(`project name "${name}" may only use letters, digits, . _ -`);
+    appendEvent(() => ({
+        type: "project.add",
+        project: { name, paths: paths.map((p) => path.resolve(p)), addedAt: new Date().toISOString() },
+    }));
+}
+export function removeProject(name) {
+    const s = fold(readEvents());
+    if (!s.projects.has(name))
+        throw new UserError(`no project named "${name}"`);
+    appendEvent(() => ({ type: "project.remove", name }));
+}
+const PREVIEW_MAX = 20_000;
+function readPreview(file) {
+    if (!file?.trim())
+        return undefined;
+    let text;
+    try {
+        text = fs.readFileSync(path.resolve(file), "utf8");
+    }
+    catch {
+        throw new UserError(`cannot read the preview file ${file}`);
+    }
+    return text.length > PREVIEW_MAX ? text.slice(0, PREVIEW_MAX) + "\n…" : text;
+}
+/** A date or timestamp as ISO text; a bare date counts as local midnight. */
+export function parseWhen(s) {
+    const t = s.trim();
+    const d = /^\d{4}-\d{2}-\d{2}$/.test(t) ? new Date(`${t}T00:00:00`) : new Date(t);
+    if (Number.isNaN(d.getTime()))
+        throw new UserError(`"${s}" is not a date (use YYYY-MM-DD)`);
+    return d.toISOString();
+}
+/** The claimed name of a session (claims may hold an id prefix). */
+export function sessionTitle(claims, session) {
+    if (!session)
+        return undefined;
+    const c = claims.find((x) => session.startsWith(x.session) || x.session.startsWith(session));
+    return c?.title;
+}
+function checkKind(kind) {
+    if (!CARD_KINDS.includes(kind))
+        throw new UserError(`kind must be one of ${CARD_KINDS.join(", ")}`);
+    return kind;
+}
+export function openCard(input) {
+    if (!input.title.trim())
+        throw new UserError("a card needs a title");
+    if (!input.project.trim())
+        throw new UserError("a card needs --project");
+    const action = input.action?.trim() || undefined;
+    // an approval with no choices of its own is a yes or a no
+    const options = cleanList(input.options) ?? (action ? ["Do it", "Don't"] : undefined);
+    const preview = readPreview(input.preview);
+    if (input.recommend !== undefined) {
+        if (!options)
+            throw new UserError("--recommend needs --option");
+        if (!Number.isInteger(input.recommend) || input.recommend < 1 || input.recommend > options.length) {
+            throw new UserError(`--recommend must be between 1 and ${options.length}`);
+        }
+    }
+    checkKind(input.kind);
+    const since = input.since?.trim() ? parseWhen(input.since) : undefined;
+    let id = "";
+    appendEvent((events) => {
+        id = nextId(events, "c");
+        const session = input.session?.trim() || undefined;
+        const from = input.from?.trim() || sessionTitle(fold(events).claims, session);
+        return {
+            type: "card.open",
+            card: {
+                id,
+                kind: input.kind,
+                project: input.project,
+                task: input.task || undefined,
+                title: input.title.trim(),
+                body: input.body?.trim() || undefined,
+                options,
+                recommend: input.recommend,
+                attach: absPaths(input.attach),
+                open: absPaths(input.open),
+                look: input.look?.trim() || undefined,
+                from,
+                session,
+                since,
+                action,
+                preview,
+            },
+        };
+    });
+    const card = fold(readEvents()).cards.get(id);
+    if (!card)
+        throw new Error("card vanished right after it was written");
+    return card;
+}
+function requireCard(id) {
+    const card = fold(readEvents()).cards.get(id);
+    if (!card)
+        throw new UserError(`no card "${id}"`);
+    return card;
+}
+export function answerCard(id, a) {
+    const card = requireCard(id);
+    if (card.status === "closed")
+        throw new UserError(`card ${id} is already closed`);
+    if (a.choice === undefined && !a.comment?.trim() && !cleanList(a.attach)) {
+        throw new UserError("an answer needs --choice, --comment or --attach");
+    }
+    if (a.choice !== undefined) {
+        const n = card.options?.length ?? 0;
+        if (!Number.isInteger(a.choice) || a.choice < 1 || a.choice > n) {
+            throw new UserError(n ? `--choice must be between 1 and ${n}` : `card ${id} has no options`);
+        }
+    }
+    appendEvent(() => ({
+        type: "card.answer",
+        card: id,
+        by: a.by || HUMAN,
+        choice: a.choice,
+        comment: a.comment?.trim() || undefined,
+        attach: absPaths(a.attach),
+    }));
+}
+export function commentCard(id, text, by) {
+    requireCard(id);
+    if (!text.trim())
+        throw new UserError("a comment needs text");
+    appendEvent(() => ({ type: "card.comment", card: id, by, text: text.trim() }));
+}
+export function editCard(id, set) {
+    requireCard(id);
+    const clean = {};
+    if (set.kind !== undefined)
+        clean.kind = checkKind(set.kind);
+    if (set.title !== undefined) {
+        if (!set.title.trim())
+            throw new UserError("a card needs a title");
+        clean.title = set.title.trim();
+    }
+    // an empty value clears the field; null survives JSON where undefined would vanish
+    const cleared = null;
+    if (set.body !== undefined)
+        clean.body = set.body.trim() || cleared;
+    if (set.task !== undefined)
+        clean.task = set.task.trim() || cleared;
+    if (set.from !== undefined)
+        clean.from = set.from.trim() || cleared;
+    if (set.session !== undefined)
+        clean.session = set.session.trim() || cleared;
+    if (set.since !== undefined)
+        clean.since = set.since.trim() ? parseWhen(set.since) : cleared;
+    if (!Object.keys(clean).length)
+        throw new UserError("nothing to change");
+    appendEvent(() => ({ type: "card.edit", card: id, set: clean }));
+    return requireCard(id);
+}
+export function closeCard(id, note) {
+    const card = requireCard(id);
+    if (card.status === "closed")
+        return;
+    appendEvent(() => ({ type: "card.close", card: id, note: note?.trim() || undefined }));
+}
+export function startRun(r) {
+    if (r.heartbeat !== undefined && (!Number.isFinite(r.heartbeat) || r.heartbeat <= 0))
+        throw new UserError("--heartbeat must be a number of seconds above 0");
+    const log = r.log?.trim() ? path.resolve(r.log) : undefined;
+    let id = "";
+    appendEvent((events) => {
+        id = nextId(events, "r");
+        return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent, heartbeat: r.heartbeat, log } };
+    });
+    return id;
+}
+export function noteRun(id, text) {
+    if (!fold(readEvents()).runs.has(id))
+        throw new UserError(`no declared run "${id}"`);
+    appendEvent(() => ({ type: "run.note", run: id, text }));
+}
+export function beatRun(id) {
+    if (!fold(readEvents()).runs.has(id))
+        throw new UserError(`no declared run "${id}"`);
+    appendEvent(() => ({ type: "run.beat", run: id }));
+}
+export function endRun(id, status, note) {
+    if (!fold(readEvents()).runs.has(id))
+        throw new UserError(`no declared run "${id}"`);
+    appendEvent(() => ({ type: "run.end", run: id, status, note }));
+}
+/**
+ * Say which project and task a session works on. A claim without a project keeps the session's
+ * earlier claim and only changes what is given (for `--done`). A claim of a new task clears `done`.
+ */
+export function claimSession(input) {
+    if (input.session.length < 6)
+        throw new UserError("give at least 6 characters of the session id");
+    const before = fold(readEvents()).claims.find((c) => c.session === input.session);
+    const project = input.project?.trim() || before?.project;
+    if (!project)
+        throw new UserError("this session has not claimed a project yet: give --project");
+    const sameWork = !input.project || (input.project === before?.project && (input.task ?? before?.task) === before?.task);
+    const claim = {
+        session: input.session,
+        project,
+        task: input.task ?? (sameWork ? before?.task : undefined),
+        role: input.role ?? before?.role,
+        title: input.title ?? before?.title,
+        kind: input.kind ?? before?.kind,
+        // any new claim means work goes on; only --done marks it finished
+        done: input.done?.trim() || undefined,
+    };
+    for (const k of Object.keys(claim))
+        if (claim[k] === undefined)
+            delete claim[k];
+    appendEvent(() => ({ type: "run.claim", claim }));
+    return claim;
+}
+// ---------------------------------------------------------------- pull requests
+export function linkPr(link) {
+    const claims = fold(readEvents()).claims;
+    const claim = link.session ? claims.find((c) => link.session.startsWith(c.session)) : undefined;
+    const project = link.project?.trim() || claim?.project;
+    appendEvent(() => ({
+        type: "pr.link",
+        link: { pr: link.pr, session: link.session, project, task: link.task?.trim() || claim?.task },
+    }));
+}
+export function unlinkPr(key) {
+    if (!fold(readEvents()).prLinks.has(key))
+        throw new UserError(`no linked pull request ${key}`);
+    appendEvent(() => ({ type: "pr.unlink", pr: key }));
+}
+/** Something another tool saw on a PR (a merge bot, a ticket system), recorded like GitHub's own. */
+export function prEvent(pr, change, opts = {}) {
+    if (!PR_CHANGES.includes(change))
+        throw new UserError(`change must be one of ${PR_CHANGES.join(", ")}`);
+    appendEvent(() => ({ type: "pr.change", pr, change: change, by: opts.by, text: opts.text?.trim() || undefined, title: opts.title, source: "external" }));
+}
+/**
+ * Human answers and comments newer than `afterSeq`, on cards that are not closed, and news on pull
+ * requests linked to the project.
+ */
+export function inboxFrom(events, afterSeq, filter) {
+    const state = fold(events);
+    const out = [];
+    for (const ev of events) {
+        if (ev.seq <= afterSeq)
+            continue;
+        if (ev.type === "pr.change") {
+            const link = state.prLinks.get(ev.pr.key);
+            if (!link || filter.card || (filter.project && link.project !== filter.project))
+                continue;
+            out.push({ seq: ev.seq, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
+            continue;
+        }
+        if (ev.type !== "card.answer" && ev.type !== "card.comment")
+            continue;
+        if (ev.by !== HUMAN)
+            continue;
+        const card = state.cards.get(ev.card);
+        if (!card || card.status === "closed")
+            continue;
+        if (filter.project && card.project !== filter.project)
+            continue;
+        if (filter.card && card.id !== filter.card)
+            continue;
+        if (ev.type === "card.answer") {
+            out.push({
+                seq: ev.seq,
+                at: ev.ts,
+                kind: "answer",
+                card,
+                by: ev.by,
+                choice: ev.choice,
+                choiceText: ev.choice !== undefined ? card.options?.[ev.choice - 1] : undefined,
+                comment: ev.comment,
+                attach: ev.attach,
+            });
+        }
+        else {
+            out.push({ seq: ev.seq, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------- listeners
+function listenersDir() {
+    return path.join(homeDir(), "listeners");
+}
+/** Mark this process as waiting, so cards can say whether an answer reaches an agent at once. */
+export function startListening(l) {
+    const file = path.join(listenersDir(), `${process.pid}.json`);
+    fs.mkdirSync(listenersDir(), { recursive: true });
+    const me = { ...l, pid: process.pid, since: new Date().toISOString() };
+    fs.writeFileSync(file, JSON.stringify(me) + "\n");
+    let done = false;
+    const stop = () => {
+        if (done)
+            return;
+        done = true;
+        fs.rmSync(file, { force: true });
+    };
+    process.once("exit", stop);
+    for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.once(sig, () => {
+            stop();
+            process.exit(128 + (sig === "SIGINT" ? 2 : sig === "SIGTERM" ? 15 : 1));
+        });
+    }
+    return stop;
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** Waits running now. Files left by a process that died are removed. */
+export function listeners() {
+    let names;
+    try {
+        names = fs.readdirSync(listenersDir()).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const file = path.join(listenersDir(), n);
+        try {
+            const l = JSON.parse(fs.readFileSync(file, "utf8"));
+            if (alive(l.pid))
+                out.push(l);
+            else
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            // half written; read it next time
+        }
+    }
+    return out;
+}
+/** The waits an answer to this card would wake right now. */
+export function listenersFor(card, ls) {
+    return ls.filter((l) => (l.card ? l.card === card.id : !l.project || l.project === card.project));
+}
+export function consumerName(opts) {
+    return opts.as || opts.project || (opts.card ? `card-${opts.card}` : "default");
+}
+export function readInbox(consumer, filter, advance) {
+    const events = readEvents();
+    const items = inboxFrom(events, readCursor(consumer), filter);
+    const last = items[items.length - 1];
+    if (advance && last)
+        writeCursor(consumer, last.seq);
+    return items;
+}
+/**
+ * Block until the consumer has something in its inbox, or the timeout passes.
+ * Returns the items (cursor advanced) or [] on timeout.
+ */
+export async function waitInbox(consumer, filter, timeoutMs, pollMs = 1000) {
+    const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : Infinity;
+    let watcher;
+    let wake;
+    try {
+        const dir = path.dirname(eventsPath());
+        fs.mkdirSync(dir, { recursive: true });
+        watcher = fs.watch(dir, () => wake?.());
+    }
+    catch {
+        watcher = undefined; // polling alone still works
+    }
+    try {
+        for (;;) {
+            const items = readInbox(consumer, filter, true);
+            if (items.length)
+                return items;
+            const left = deadline - Date.now();
+            if (left <= 0)
+                return [];
+            await new Promise((resolve) => {
+                const t = setTimeout(resolve, Math.min(pollMs, left));
+                wake = () => {
+                    clearTimeout(t);
+                    resolve();
+                };
+            });
+            wake = undefined;
+        }
+    }
+    finally {
+        watcher?.close();
+    }
+}
+//# sourceMappingURL=ops.js.map

package/dist/core/runs.js

@@ -0,0 +1,284 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { scanAll } from "../adapters/index.js";
+import { ACTIVITY_MINUTES, activeMinutes } from "../adapters/jsonl.js";
+/** All checkouts of a project path: the path itself plus its git worktrees. */
+function rootsOf(p, cache) {
+    const hit = cache.get(p);
+    if (hit)
+        return hit;
+    const roots = [p];
+    try {
+        const git = (args) => execFileSync("git", ["-C", p, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 });
+        // a folder inside a bigger repo (a notes vault, a monorepo package) must not claim the whole repo
+        const top = git(["rev-parse", "--show-toplevel"]).trim();
+        if (path.resolve(top) !== path.resolve(p)) {
+            cache.set(p, roots);
+            return roots;
+        }
+        const out = git(["worktree", "list", "--porcelain"]);
+        for (const line of out.split("\n")) {
+            if (line.startsWith("worktree ")) {
+                const w = line.slice("worktree ".length).trim();
+                if (w && !roots.includes(w))
+                    roots.push(w);
+            }
+        }
+    }
+    catch {
+        // not a git checkout, or git missing; the path alone still matches
+    }
+    cache.set(p, roots);
+    return roots;
+}
+function inside(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function matchers(projects) {
+    const cache = new Map();
+    return projects.map((p) => ({ project: p.name, roots: p.paths.flatMap((x) => rootsOf(x, cache)) }));
+}
+/** The project whose checkout holds this directory; the deepest root wins. */
+function projectForCwd(cwd, ms) {
+    if (!cwd)
+        return undefined;
+    let best;
+    for (const m of ms) {
+        for (const r of m.roots) {
+            if (inside(cwd, r) && (!best || r.length > best.depth))
+                best = { project: m.project, depth: r.length };
+        }
+    }
+    return best?.project;
+}
+/** A project whose path the run's first prompt names, when exactly one does. */
+function projectForPrompt(prompt, ms) {
+    if (!prompt)
+        return undefined;
+    const hits = new Set();
+    for (const m of ms) {
+        for (const r of m.roots)
+            if (prompt.includes(r))
+                hits.add(m.project);
+    }
+    return hits.size === 1 ? [...hits][0] : undefined;
+}
+/** The project most of these folders belong to (ties go to the most recent), with its count. */
+function projectForEdits(dirs, ms) {
+    const counts = new Map();
+    for (const d of dirs ?? []) {
+        const p = projectForCwd(d, ms);
+        if (p)
+            counts.set(p, (counts.get(p) ?? 0) + 1);
+    }
+    return counts;
+}
+function topOf(counts, dirs, ms) {
+    let best;
+    let n = 0;
+    // walk newest first so a tie goes to where the run worked last
+    for (const d of [...(dirs ?? [])].reverse()) {
+        const p = projectForCwd(d, ms);
+        if (p && (counts.get(p) ?? 0) > n) {
+            best = p;
+            n = counts.get(p);
+        }
+    }
+    return best;
+}
+function claimFor(id, state) {
+    return state.claims.find((c) => id.startsWith(c.session));
+}
+/**
+ * Give each observed run a project, in this order: an explicit claim; the checkout it runs in,
+ * unless it only edits files of another project; its parent's project; the project whose files it
+ * edits most; a project path named in its first prompt.
+ */
+export function attribute(runs, state) {
+    const ms = matchers([...state.projects.values()]);
+    const byId = new Map(runs.map((r) => [r.id, r]));
+    for (const r of runs) {
+        const claim = claimFor(r.id, state);
+        if (claim) {
+            r.project = claim.project;
+            r.projectSource = "claim";
+            r.task = claim.task ?? r.task;
+            r.role = claim.role ?? r.role;
+            if (claim.title)
+                r.title = claim.title;
+            if (claim.kind === "scheduled")
+                r.scheduled = true;
+            // done until someone writes to the session again
+            if (claim.done && claim.at && (!r.lastPromptAt || r.lastPromptAt < claim.at)) {
+                r.done = claim.done;
+                if (r.state === "idle")
+                    r.state = "done";
+                r.asks = undefined;
+            }
+            continue;
+        }
+        const here = projectForCwd(r.cwd, ms);
+        const edits = projectForEdits(r.touched, ms);
+        if (here && !r.parent && edits.size && !edits.has(here)) {
+            r.project = topOf(edits, r.touched, ms);
+            r.projectSource = "edits";
+        }
+        else if (here) {
+            r.project = here;
+            r.projectSource = "cwd";
+        }
+    }
+    // parents may themselves get a project only from a claim, so resolve children afterwards
+    for (let pass = 0; pass < 3; pass++) {
+        for (const r of runs) {
+            if (r.project || !r.parent)
+                continue;
+            const p = byId.get(r.parent);
+            const project = p?.project ?? claimFor(r.parent, state)?.project;
+            if (project) {
+                r.project = project;
+                r.projectSource = "parent";
+            }
+        }
+    }
+    for (const r of runs) {
+        if (r.project)
+            continue;
+        const edits = topOf(projectForEdits(r.touched, ms), r.touched, ms);
+        const prompt = edits ? undefined : projectForPrompt(r.prompt, ms);
+        r.project = edits ?? prompt;
+        if (r.project)
+            r.projectSource = edits ? "edits" : "prompt";
+    }
+    return runs;
+}
+/**
+ * Fold repeated runs of a scheduled task into the newest one, with a count. Runs claimed as
+ * scheduled group by project and task; unclaimed top-level sessions group by an identical first
+ * prompt. A run still working is never folded away.
+ */
+export function foldRepeats(runs) {
+    const groups = new Map();
+    for (const r of runs) {
+        if (r.kind !== "session" || r.parent)
+            continue;
+        const key = r.scheduled ? `s:${r.project}:${r.task ?? r.title}` : r.projectSource === "claim" || !r.prompt ? undefined : `p:${r.prompt}`;
+        if (!key)
+            continue;
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(r);
+    }
+    const drop = new Set();
+    for (const g of groups.values()) {
+        if (g.length < 2)
+            continue;
+        g.sort((a, b) => (b.lastActivity ?? "").localeCompare(a.lastActivity ?? ""));
+        const [newest, ...older] = g;
+        let n = 0;
+        for (const r of older) {
+            if (r.state === "working" || r.state === "waiting" || r.asks)
+                continue;
+            drop.add(r);
+            n++;
+        }
+        if (n) {
+            newest.repeats = n;
+            newest.scheduled = true;
+        }
+    }
+    // children of a folded run go with it
+    const gone = new Set([...drop].map((r) => r.id));
+    return runs.filter((r) => !drop.has(r) && !(r.parent && gone.has(r.parent)));
+}
+/** Linked pull requests, put on the run that owns them. */
+function attachPrs(runs, state) {
+    for (const link of state.prLinks.values()) {
+        if (!link.session)
+            continue;
+        const r = runs.find((x) => x.id.startsWith(link.session));
+        if (r)
+            (r.prs ??= []).push(link.pr.key);
+    }
+}
+/** A declared run is busy from its start until it ends (or now, while it runs). */
+function declaredActivity(start, end, now) {
+    const from = Date.parse(start);
+    const to = end ? Date.parse(end) : now;
+    const times = [];
+    for (let t = Math.max(from, now - ACTIVITY_MINUTES * 60_000); t <= to; t += 60_000)
+        times.push(t);
+    if (to >= from)
+        times.push(to);
+    return activeMinutes(times, now);
+}
+/** When a declared run last showed life: its last beat or note, or its log file changing. */
+function lastSign(d) {
+    if (!d.log)
+        return d.lastActivity;
+    try {
+        const m = new Date(fs.statSync(d.log).mtimeMs).toISOString();
+        return m > d.lastActivity ? m : d.lastActivity;
+    }
+    catch {
+        return d.lastActivity;
+    }
+}
+export function declaredRuns(state, now = Date.now()) {
+    return [...state.runs.values()].map((d) => {
+        const last = d.status === "running" ? lastSign(d) : d.lastActivity;
+        const quiet = d.status === "running" && d.heartbeat !== undefined && now - Date.parse(last) > d.heartbeat * 1000;
+        return {
+            id: d.id,
+            runtime: "declared",
+            kind: "declared",
+            title: d.title,
+            project: d.project,
+            task: d.task,
+            parent: d.parent,
+            startedAt: d.startedAt,
+            lastActivity: last,
+            state: quiet ? "stalled" : d.status === "running" ? "working" : d.status,
+            action: quiet ? `no sign of life for ${Math.round((now - Date.parse(last)) / 60_000)}m${d.note ? ` · ${d.note}` : ""}` : d.note,
+            projectSource: "claim",
+            activity: declaredActivity(d.startedAt, d.status === "running" ? undefined : (d.endedAt ?? d.lastActivity), now),
+        };
+    });
+}
+const ENDED = new Set(["done", "idle", "failed"]);
+const RECENT_END_MS = 30 * 60_000;
+const OLD_STALL_MS = 3 * 3_600_000;
+export function collectRuns(state, q, now = Date.now()) {
+    const sinceMs = now - q.sinceHours * 3_600_000;
+    // a log file can be touched (title records, snapshots) long after its last real activity
+    const recent = (r) => !r.lastActivity || Date.parse(r.lastActivity) >= sinceMs;
+    let runs = attribute(scanAll({ sinceMs, now }, q.runtimes), state).filter(recent);
+    runs.push(...declaredRuns(state, now).filter(recent));
+    attachPrs(runs, state);
+    if (q.project)
+        runs = runs.filter((r) => r.project === q.project);
+    if (!q.includeEnded) {
+        // keep what is moving, plus things that finished in the last half hour and parents of live children
+        const live = new Set(runs.filter((r) => !ENDED.has(r.state)).map((r) => r.parent).filter(Boolean));
+        runs = runs.filter((r) => {
+            // a run quiet for hours is almost always gone, not stuck; --all still shows it
+            if (r.state === "stalled")
+                return r.lastActivity ? now - Date.parse(r.lastActivity) < OLD_STALL_MS : true;
+            if (!ENDED.has(r.state))
+                return true;
+            if (r.asks)
+                return true; // still waiting for the human to read it
+            if (live.has(r.id))
+                return true;
+            if (r.role === "lead")
+                return true;
+            return r.lastActivity ? now - Date.parse(r.lastActivity) < RECENT_END_MS : false;
+        });
+    }
+    if (!q.keepRepeats)
+        runs = foldRepeats(runs);
+    return runs.sort((a, b) => (b.lastActivity ?? "").localeCompare(a.lastActivity ?? ""));
+}
+//# sourceMappingURL=runs.js.map