@cmgmyr/hive 1.2.2 → 1.4.0

package/dist/leadWatch.js

@@ -0,0 +1,73 @@
+import { db } from "./db.js";
+import { paneClassifierFor } from "./harnesses.js";
+import { readLeadTurnState } from "./leadState.js";
+import { LEAD_KIND } from "./spawn.js";
+import { holdsHumanInput, paneReissued, rowAliveProbe } from "./tmux.js";
+export const LEAD_TARGET_GONE = "LEAD_TARGET_GONE";
+export const LEAD_TARGET_REISSUED = "LEAD_TARGET_REISSUED";
+export const LEAD_TARGET_RESTARTED = "LEAD_TARGET_RESTARTED";
+const directPaneReaders = {
+    awaitingChoice: (pane, command) => paneClassifierFor(command)?.choiceCheck(pane).awaitingChoice ?? null,
+    holdsInput: (pane, command) => holdsHumanInput(paneClassifierFor(command)?.inputBoxState(pane) ?? null),
+};
+export function leadSubscription(wakeId) {
+    return (db.prepare("SELECT * FROM lead_idle_subscriptions WHERE wake_id = ?").get(wakeId) ??
+        null);
+}
+export function runningLeadOf(projectId) {
+    return (db
+        .prepare(`SELECT id, name, status, tmux_target, tmux_socket, pane_pid, command FROM agents
+          WHERE project_id = ? AND kind = ? AND status = 'running' ORDER BY id LIMIT 1`)
+        .get(projectId, LEAD_KIND) ?? null);
+}
+// Reads the watched lead's screen only to stay quiet; it can never make a lead read idle.
+export function paneVeto(lead, readers = directPaneReaders) {
+    const choice = readers.awaitingChoice(lead.tmux_target, lead.command);
+    if (choice === true)
+        return "it is on a dialog";
+    if (choice === null)
+        return "its screen could not be read";
+    if (readers.holdsInput(lead.tmux_target, lead.command))
+        return "it has unsubmitted text in its input box";
+    return null;
+}
+export function evaluateLeadWatch(sub, mode, snapshot, readers) {
+    const lead = db
+        .prepare("SELECT id, name, status, tmux_target, tmux_socket, pane_pid, command FROM agents WHERE id = ? AND kind = ?")
+        .get(sub.agent_id, LEAD_KIND);
+    if (!lead || lead.status !== "running")
+        return { kind: "invalid", reason: LEAD_TARGET_GONE };
+    if (lead.pane_pid !== sub.pane_pid)
+        return { kind: "invalid", reason: LEAD_TARGET_RESTARTED };
+    if (snapshot === null)
+        return { kind: "pending", reason: "tmux did not answer" };
+    const probe = rowAliveProbe(lead.tmux_socket, lead.tmux_target, snapshot);
+    if (probe.live === null)
+        return { kind: "pending", reason: "its pane cannot be probed from this process" };
+    if (!probe.live)
+        return { kind: "invalid", reason: LEAD_TARGET_GONE };
+    if (paneReissued(sub.pane_pid, probe))
+        return { kind: "invalid", reason: LEAD_TARGET_REISSUED };
+    const state = readLeadTurnState(lead.id);
+    if (state === null || state.pane_pid !== sub.pane_pid)
+        return { kind: "pending", reason: "no turn recorded yet" };
+    let session = sub.session_id;
+    if (session === "" && state.state !== "unknown") {
+        session = state.session_id;
+        try {
+            db.prepare("UPDATE lead_idle_subscriptions SET session_id = ? WHERE wake_id = ? AND session_id = ''").run(session, sub.wake_id);
+        }
+        catch {
+            // Unbound for another tick; the in-memory binding still judges this one.
+        }
+    }
+    if (session !== "" && state.session_id !== session)
+        return { kind: "invalid", reason: LEAD_TARGET_RESTARTED };
+    const ended = mode === "any" ? state.idle_seq > sub.baseline_idle_seq : state.state === "idle";
+    if (!ended)
+        return { kind: "pending", reason: `its turn state is ${state.state}` };
+    const vetoed = paneVeto(lead, readers);
+    if (vetoed !== null)
+        return { kind: "pending", reason: `its turn ended, but ${vetoed}` };
+    return { kind: "idle", idle_seq: state.idle_seq };
+}

package/dist/portfolio.js

@@ -0,0 +1,210 @@
+import { db } from "./db.js";
+import { listProjects } from "./context.js";
+import { existsSync } from "node:fs";
+import { parseTags } from "./result.js";
+import { OPEN_BLOCKERS_SQL } from "./tools/todos.js";
+import { readLeadTurnState } from "./leadState.js";
+import { liveTargets, paneReissued, rowAlive, rowAliveProbe } from "./tmux.js";
+export const PORTFOLIO_REASONS = [
+    "needs_human",
+    "dead_lead_pane",
+    "missing_root_with_work",
+    "worker_needs_input",
+    "wake_overdue_5m",
+    "in_progress_blocked",
+    "all_active_todos_blocked",
+    "stale_in_progress_48h",
+    "worker_working",
+    "todo_in_progress",
+    "wake_due_24h",
+    "quiet",
+];
+export const NEEDS_HUMAN_TAG = "needs-human";
+const NEEDS_HUMAN_ITEM_CAP = 5;
+const WAKE_OVERDUE_GRACE = "-5 minutes";
+const STALE_IN_PROGRESS = "-48 hours";
+const WAKE_UPCOMING = "+24 hours";
+export const ACTIVE_WAKE_WHERE = "cancelled_at IS NULL AND (fired_at IS NULL OR repeat_every_ms IS NOT NULL)";
+export function leadText(p) {
+    return p.lead.state === "alive" && p.lead.turn !== "unknown"
+        ? `alive, turn ${p.lead.turn === "working" ? "working" : "ended"}`
+        : p.lead.state;
+}
+function leadTurnFor(agentId, panePid) {
+    const row = readLeadTurnState(agentId);
+    if (row === null || row.pane_pid !== panePid)
+        return "unknown";
+    return row.state === "working" ? "working" : row.state === "idle" ? "turn_ended" : "unknown";
+}
+const ONE = (sql, ...params) => db.prepare(sql).get(...params);
+function shiftedClock(now, modifier) {
+    return ONE("SELECT datetime(?, ?) AS t", now, modifier).t;
+}
+function lastActivity(projectId, countWakeFires = true) {
+    const row = ONE(`SELECT MAX(t) AS t FROM (
+       SELECT created_at AS t FROM projects WHERE id = :pid
+       UNION ALL SELECT updated_at FROM todos WHERE project_id = :pid
+       UNION ALL SELECT c.created_at FROM todo_comments c JOIN todos t ON t.id = c.todo_id WHERE t.project_id = :pid
+       UNION ALL SELECT updated_at FROM pads WHERE project_id = :pid
+       UNION ALL SELECT created_at FROM agents WHERE project_id = :pid
+       UNION ALL SELECT state_changed_at FROM agents WHERE project_id = :pid
+       UNION ALL SELECT substr(l.created_at, 1, 19) FROM agent_state_log l
+         WHERE l.actor_id IN (SELECT actor_id FROM agents WHERE project_id = :pid)
+       UNION ALL SELECT created_at FROM wakes WHERE project_id = :pid
+       ${countWakeFires ? "UNION ALL SELECT fired_at FROM wakes WHERE project_id = :pid" : ""}
+     )`, { pid: projectId });
+    return row.t;
+}
+function projectRow(project, now, snapshot) {
+    const rootExists = existsSync(project.path);
+    const todoRows = db
+        .prepare(`SELECT t.id, t.title, t.slug, t.priority, t.status, t.tags, t.updated_at,
+              EXISTS (${OPEN_BLOCKERS_SQL}) AS blocked
+         FROM todos t
+        WHERE t.project_id = ? AND t.status IN ('open', 'in_progress') AND t.archived_at IS NULL`)
+        .all(project.id);
+    const todos = { open: 0, in_progress: 0, blocked: 0, blocked_in_progress: 0, high: 0 };
+    const tagged = [];
+    for (const t of todoRows) {
+        if (t.status === "open")
+            todos.open++;
+        else
+            todos.in_progress++;
+        if (t.blocked) {
+            todos.blocked++;
+            if (t.status === "in_progress")
+                todos.blocked_in_progress++;
+        }
+        if (t.priority === "high")
+            todos.high++;
+        if (parseTags(t.tags).includes(NEEDS_HUMAN_TAG))
+            tagged.push(t);
+    }
+    tagged.sort((a, b) => (a.updated_at < b.updated_at ? -1 : a.updated_at > b.updated_at ? 1 : a.id - b.id));
+    const agents = db
+        .prepare("SELECT id, kind, agent_state, tmux_target, tmux_socket, pane_pid FROM agents WHERE project_id = ? AND status = 'running' ORDER BY id")
+        .all(project.id);
+    const liveness = (a) => snapshot ? rowAlive(a.tmux_socket, a.tmux_target, snapshot) : null;
+    const reissued = (a) => snapshot !== null && paneReissued(a.pane_pid, rowAliveProbe(a.tmux_socket, a.tmux_target, snapshot));
+    const workers = { working: 0, idle: 0, needs_input: 0, other: 0, unreachable: 0, unconfirmed: 0 };
+    let liveWorking = 0;
+    let liveWaiting = 0;
+    let lead = { state: "none", agent_id: null, turn: "unknown" };
+    for (const a of agents) {
+        if (a.kind === "lead") {
+            const live = reissued(a) ? false : liveness(a);
+            lead = {
+                state: live === true ? "alive" : live === false ? "dead_pane" : "unknown",
+                agent_id: a.id,
+                turn: live === true ? leadTurnFor(a.id, a.pane_pid) : "unknown",
+            };
+            continue;
+        }
+        if (a.kind !== "agent")
+            continue;
+        const live = reissued(a) ? false : liveness(a);
+        if (live === false)
+            workers.unreachable++;
+        else if (live === null)
+            workers.unconfirmed++;
+        else if (a.agent_state === "working") {
+            workers.working++;
+            liveWorking++;
+        }
+        else if (a.agent_state === "idle")
+            workers.idle++;
+        else if (a.agent_state === "waiting") {
+            workers.needs_input++;
+            liveWaiting++;
+        }
+        else
+            workers.other++;
+    }
+    const overdueBefore = shiftedClock(now, WAKE_OVERDUE_GRACE);
+    const upcomingUntil = shiftedClock(now, WAKE_UPCOMING);
+    const wakeCounts = db
+        .prepare(`SELECT COUNT(*) AS pending,
+              COALESCE(SUM(held_at IS NULL AND COALESCE(due_at, max_wait_at) < ?), 0) AS overdue,
+              COALESCE(SUM(held_at IS NULL AND COALESCE(due_at, max_wait_at) <= ?), 0) AS overdue_grace,
+              COALESCE(SUM(COALESCE(due_at, max_wait_at) > ? AND COALESCE(due_at, max_wait_at) <= ?), 0) AS upcoming
+         FROM wakes WHERE project_id = ? AND ${ACTIVE_WAKE_WHERE}`)
+        .get(now, overdueBefore, overdueBefore, upcomingUntil, project.id);
+    const lastActivityAt = lastActivity(project.id);
+    const staleClock = lastActivity(project.id, false);
+    const staleBefore = shiftedClock(now, STALE_IN_PROGRESS);
+    const activeTodos = todos.open + todos.in_progress;
+    const found = new Set();
+    if (tagged.length > 0)
+        found.add("needs_human");
+    if (lead.state === "dead_pane" && (todos.in_progress > 0 || wakeCounts.pending > 0))
+        found.add("dead_lead_pane");
+    if (!rootExists && (activeTodos > 0 || wakeCounts.pending > 0))
+        found.add("missing_root_with_work");
+    if (liveWaiting > 0)
+        found.add("worker_needs_input");
+    if (wakeCounts.overdue_grace > 0)
+        found.add("wake_overdue_5m");
+    if (todos.blocked_in_progress > 0)
+        found.add("in_progress_blocked");
+    if (activeTodos > 0 && todos.blocked === activeTodos)
+        found.add("all_active_todos_blocked");
+    if (todos.in_progress > 0 && liveWorking === 0 && staleClock <= staleBefore)
+        found.add("stale_in_progress_48h");
+    if (liveWorking > 0)
+        found.add("worker_working");
+    if (todos.in_progress > 0)
+        found.add("todo_in_progress");
+    if (wakeCounts.upcoming > 0)
+        found.add("wake_due_24h");
+    const HARD_STALL = [
+        "dead_lead_pane",
+        "missing_root_with_work",
+        "worker_needs_input",
+        "wake_overdue_5m",
+    ];
+    const TODO_GRAPH = ["in_progress_blocked", "all_active_todos_blocked", "stale_in_progress_48h"];
+    const freshInProgress = todos.in_progress > todos.blocked_in_progress && !found.has("stale_in_progress_48h");
+    const movingSignal = liveWorking > 0 || freshInProgress;
+    let lane;
+    if (HARD_STALL.some((r) => found.has(r)))
+        lane = "stuck";
+    else if (movingSignal)
+        lane = "moving";
+    else if (found.has("needs_human"))
+        lane = "waiting_on_you";
+    else if (TODO_GRAPH.some((r) => found.has(r)))
+        lane = "stuck";
+    else {
+        lane = "quiet";
+        found.add("quiet");
+    }
+    return {
+        id: project.id,
+        name: project.name,
+        root: project.path,
+        root_exists: rootExists,
+        lane,
+        reasons: PORTFOLIO_REASONS.filter((r) => found.has(r)),
+        lead,
+        workers,
+        todos,
+        needs_human: tagged.length,
+        needs_human_items: tagged.slice(0, NEEDS_HUMAN_ITEM_CAP).map((t) => ({
+            todo_id: t.id,
+            title: t.title,
+            slug: t.slug === "" ? null : t.slug,
+            updated_at: t.updated_at,
+        })),
+        last_activity_at: lastActivityAt,
+        wakes: { pending: wakeCounts.pending, overdue: wakeCounts.overdue },
+    };
+}
+export function collectPortfolio(now) {
+    const asOf = now ?? ONE("SELECT datetime('now') AS now").now;
+    const snapshot = liveTargets();
+    const projects = listProjects().map((p) => projectRow(p, asOf, snapshot));
+    const lanes = { waiting_on_you: 0, stuck: 0, moving: 0, quiet: 0 };
+    for (const p of projects)
+        lanes[p.lane]++;
+    return { schema_version: 1, as_of: asOf, totals: { projects: projects.length, lanes }, projects };
+}