@cmgmyr/hive 1.2.2 → 1.4.0

package/dist/scheduler.js

@@ -1,21 +1,26 @@
+import { QUEEN_AUDIT_RETENTION, QUEEN_AUDIT_MAX_ROWS, recentQueenAudit } from "./queenAudit.js";
 import { runningBuildChange, runningBuildNotice } from "./version.js";
-import { existsSync, mkdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { dirname, join, sep } from "node:path";
 import { dataDir, db, storeReplaced } from "./db.js";
 import { maybeBackupHourly } from "./backup.js";
 import { renderDashboardForWrite } from "./dashboard.js";
 import { snapshotProcesses } from "./processes.js";
 import { loadProjectYml } from "./projectYml.js";
-import { listProjects } from "./context.js";
+import { getProjectByPath, listProjects, queenHomeDir } from "./context.js";
+import { collectPortfolio } from "./portfolio.js";
+import { QUEEN_GENERATED_MARKER, readQueenBrief, renderQueenDashboard } from "./queenDashboard.js";
 import { COMMAND_KIND, stoppingMarkerLive } from "./processes.js";
 import { closeAgentRow, isLeadActorId, LEAD_ACTOR_PREFIX, LEAD_KIND, reapCodexHomeForClosedAgent } from "./spawn.js";
 import { awaitingFirstPrompt, awaitingFirstPromptSql } from "./firstPrompt.js";
+import { evaluateLeadWatch, leadSubscription } from "./leadWatch.js";
 import { describeLiveTasks, describeOneTask, liveBackgroundTasks, STALL_BOUND_SECONDS, } from "./backgroundTasks.js";
 import { MESSAGE_MAX_ROWS, MESSAGE_RETENTION } from "./leadMessage.js";
 import { harnessFor, hasTranscriptSignal, paneClassifierFor, screenClassifiable, transcriptDirFor } from "./harnesses.js";
 import { transcriptDir, readContextFill } from "./transcript.js";
 import { ageSecondsSince, describeLastLogEvent, humanizeAge, lastLogEvent, reportsAgentStateLog, } from "./stateProvenance.js";
-import { capturePane, foreignSocket, holdsHumanInput, liveTargets, maskChoiceMarker, paneInCopyMode, paneReissued, rowAlive, rowAliveProbe, rowLiveProbe, sanitizeTail, sendText, tailCaptureLines, tmuxSocketPath, } from "./tmux.js";
+import { capturePane, foreignSocket, holdsHumanInput, liveTargets, maskChoiceMarker, paneInCopyMode, paneReissued, rowAlive, rowAliveProbe, rowLiveProbe, renderTrailerView, sanitizeTail, sendText, tailCaptureLines, sleep, tmuxSocketPath, } from "./tmux.js";
 import { appendTeardown, NOT_ATTRIBUTED, sqlNow, teardownWindow, TEARDOWN_TRIGGER, } from "./teardown.js";
 export const WATCH_SCOPE_PROJECT = "project";
 const isStandingWatch = (timer) => timer.watch_scope === WATCH_SCOPE_PROJECT;
@@ -245,6 +250,19 @@ function cancelTimer(timerId) {
 export const LOG_RETENTION = "-7 days";
 const LOG_MAX_ROWS = 20_000;
 function pruneStateLog() {
+    try {
+        const staleAudit = stmt("SELECT 1 AS hit FROM queen_audit WHERE created_at < datetime('now', ?) LIMIT 1").get(QUEEN_AUDIT_RETENTION);
+        if (staleAudit) {
+            stmt("DELETE FROM queen_audit WHERE created_at < datetime('now', ?)").run(QUEEN_AUDIT_RETENTION);
+        }
+        const hi = stmt("SELECT MAX(id) AS v FROM queen_audit").get().v;
+        const lo = stmt("SELECT MIN(id) AS v FROM queen_audit").get().v;
+        if (hi != null && lo != null && hi - lo >= QUEEN_AUDIT_MAX_ROWS) {
+            stmt("DELETE FROM queen_audit WHERE id <= ?").run(hi - QUEEN_AUDIT_MAX_ROWS);
+        }
+    }
+    catch {
+    }
     try {
         const stale = stmt("SELECT 1 AS hit FROM agent_state_log WHERE created_at < datetime('now', ?) LIMIT 1").get(LOG_RETENTION);
         if (stale) {
@@ -339,10 +357,75 @@ function maybeGenerateDashboard(project) {
     catch {
     }
 }
+function queenHome() {
+    try {
+        const home = queenHomeDir();
+        if (lstatSync(home).isSymbolicLink())
+            return null;
+        const project = getProjectByPath(realpathSync(home));
+        return project ? { id: project.id, path: home } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function renderQueenPage(queenId) {
+    const report = collectPortfolio();
+    const html = renderQueenDashboard(report, readQueenBrief(queenId, report.as_of), undefined, recentQueenAudit(10), queenId);
+    const stable = html.replace(new RegExp(`<p class="generated" ${QUEEN_GENERATED_MARKER}>[^<]*</p>`), "");
+    return { html, hash: createHash("sha256").update(stable).digest("hex") };
+}
+const QUEEN_PAGE_CLAIM_KEY = "hive:queen-page-claim";
+const QUEEN_PAGE_MARK_KEY = "hive:queen-page-mark";
+function claimQueenPageAttempt(queenId) {
+    bestEffortRun("INSERT OR IGNORE INTO kv (project_id, key, value, updated_at) VALUES (?, ?, '', '1970-01-01 00:00:00')", queenId, QUEEN_PAGE_CLAIM_KEY);
+    return (stmt(`UPDATE kv SET updated_at = datetime('now')
+       WHERE project_id = ? AND key = ?
+         AND updated_at <= datetime('now', '-${DASHBOARD_MIN_INTERVAL_SECONDS} seconds')`).run(queenId, QUEEN_PAGE_CLAIM_KEY).changes === 1);
+}
+function readQueenPageMark(queenId) {
+    const row = stmt("SELECT value FROM kv WHERE project_id = ? AND key = ?").get(queenId, QUEEN_PAGE_MARK_KEY);
+    return row?.value ?? null;
+}
+function publishQueenPage(queenId, target, page) {
+    writeDashboardAtomically(target, page.html);
+    bestEffortRun(`INSERT INTO kv (project_id, key, value) VALUES (?, ?, ?)
+     ON CONFLICT(project_id, key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')`, queenId, QUEEN_PAGE_MARK_KEY, page.hash);
+}
+export function generateQueenDashboardNow() {
+    try {
+        const home = queenHome();
+        if (home === null)
+            return null;
+        const target = join(home.path, "dashboard.html");
+        publishQueenPage(home.id, target, renderQueenPage(home.id));
+        return target;
+    }
+    catch {
+        return null;
+    }
+}
+function maybeGenerateQueenDashboard(queen) {
+    try {
+        if (!claimQueenPageAttempt(queen.id))
+            return;
+        const target = join(queen.path, "dashboard.html");
+        const page = renderQueenPage(queen.id);
+        if (readQueenPageMark(queen.id) === page.hash && existsSync(target))
+            return;
+        publishQueenPage(queen.id, target, page);
+    }
+    catch {
+    }
+}
 function maybeGenerateDashboards() {
     try {
+        const queen = queenHome();
         for (const project of listProjects()) {
-            maybeGenerateDashboard(project);
+            if (queen !== null && project.id === queen.id)
+                maybeGenerateQueenDashboard(queen);
+            else
+                maybeGenerateDashboard(project);
         }
     }
     catch {
@@ -397,8 +480,13 @@ export async function tick(snapshot) {
        )`).all();
         const choices = new Map();
         for (const timer of candidates) {
-            if (timer.kind === "delay")
+            if (timer.kind === "delay") {
                 await fireDelay(timer, snapshot, choices);
+                continue;
+            }
+            const leadWatch = leadSubscription(timer.id);
+            if (leadWatch !== null)
+                await maybeFireLeadWatch(timer, leadWatch, snapshot, now, choices);
             else
                 await maybeFireIdle(timer, snapshot, now, choices);
         }
@@ -1399,6 +1487,41 @@ function deliverable(timer, snapshot, choices) {
         firstHeldAt: timer.held_at != null ? timer.first_held_at : null,
     };
 }
+const PANE_CLAIM_TTL_SECONDS = 6;
+const PANE_CLAIM_SETTLE_MS = 500;
+const PANE_CLAIM_OWNER = "hive:scheduler";
+function acquirePaneClaim(projectId, key) {
+    try {
+        stmt("INSERT OR IGNORE INTO actors (id, name, kind) VALUES (?, 'hive scheduler', 'scheduler')").run(PANE_CLAIM_OWNER);
+        stmt("DELETE FROM leases WHERE project_id = ? AND lock_key = ? AND expires_at < datetime('now')").run(projectId, key);
+        const row = stmt(`INSERT INTO leases (project_id, lock_key, owner, expires_at)
+       VALUES (?, ?, ?, datetime('now', printf('+%d seconds', ?)))
+       ON CONFLICT(project_id, lock_key) DO NOTHING
+       RETURNING expires_at`).get(projectId, key, PANE_CLAIM_OWNER, PANE_CLAIM_TTL_SECONDS);
+        return row?.expires_at ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// Serializes check-then-type per pane ACROSS scheduler instances: the per-wake claim is atomic but two
+// instances claiming different wakes for one pane would otherwise both paste before either submits.
+// A loser skips this tick and its wake stays unclaimed.
+async function withPaneClaim(timer, fn) {
+    const key = `wake-pane:${timer.deliver_socket}:${timer.deliver_pane}`;
+    const held = timer.deliver_pane ? acquirePaneClaim(timer.project_id, key) : null;
+    if (held === null)
+        return;
+    try {
+        // Settle: a slow TUI still showing the pasted text would make the next instance hold instead of type.
+        if (await fn())
+            await sleep(PANE_CLAIM_SETTLE_MS);
+    }
+    finally {
+        // Match this acquire's expires_at: after a TTL takeover the owner is shared, so owner alone would delete the taker's row.
+        bestEffortRun("DELETE FROM leases WHERE project_id = ? AND lock_key = ? AND expires_at = ?", timer.project_id, key, held);
+    }
+}
 async function fireDelay(timer, snapshot, choices) {
     const disposition = noticeDisposition(timer);
     if (disposition === "aged") {
@@ -1413,9 +1536,12 @@ async function fireDelay(timer, snapshot, choices) {
         bestEffortRun("UPDATE wakes SET cancelled_at = datetime('now') WHERE id = ? AND created_at IS ?", timer.id, timer.created_at);
         return;
     }
+    await withPaneClaim(timer, () => fireDelayClaimed(timer, snapshot, choices));
+}
+async function fireDelayClaimed(timer, snapshot, choices) {
     const decision = deliverable(timer, snapshot, choices);
     if (!decision.ok)
-        return;
+        return false;
     let claimed;
     if (timer.repeat_every_ms != null) {
         const seconds = Math.max(1, Math.round(timer.repeat_every_ms / 1000));
@@ -1429,8 +1555,10 @@ async function fireDelay(timer, snapshot, choices) {
     else {
         claimed = claimOneShot(timer);
     }
-    if (claimed)
-        await deliver(timer, "", choices, decision.typedSeen, decision.firstHeldAt);
+    if (!claimed)
+        return false;
+    await deliver(timer, "", choices, decision.typedSeen, decision.firstHeldAt);
+    return true;
 }
 function claimOneShot(timer) {
     return (stmt(`UPDATE wakes SET fired_at = datetime('now'), fire_count = fire_count + 1
@@ -1460,6 +1588,12 @@ function watchedStates(timer, snapshot) {
         };
     });
 }
+function idleConditionMet(timer, snapshot) {
+    const states = watchedStates(timer, snapshot);
+    return timer.kind === "idle_any"
+        ? states.some((s) => s.gone || (s.idle && s.since != null && s.since >= timer.created_at))
+        : states.length > 0 && states.every((s) => s.idle);
+}
 async function maybeFireIdle(timer, snapshot, now, choices) {
     const timedOut = timer.max_wait_at != null && timer.max_wait_at <= now;
     if (isStandingWatch(timer)) {
@@ -1468,34 +1602,69 @@ async function maybeFireIdle(timer, snapshot, now, choices) {
         if (snapshot !== null && !timedOut)
             noteBlockedWatched(timer, snapshot, choices);
         if (timedOut) {
-            const decision = deliverable(timer, snapshot, choices);
-            if (decision.ok && claimOneShot(timer)) {
+            await withPaneClaim(timer, async () => {
+                const decision = deliverable(timer, snapshot, choices);
+                if (!decision.ok || !claimOneShot(timer))
+                    return false;
                 await deliver(timer, STANDING_EXPIRED_NOTE, choices, decision.typedSeen, decision.firstHeldAt);
-            }
+                return true;
+            });
         }
         return;
     }
     let ready = false;
+    let idleMet = false;
     if (timedOut) {
         ready = true;
+        if (snapshot !== null)
+            idleMet = idleConditionMet(timer, snapshot);
     }
     else {
         if (snapshot === null)
             return;
-        const states = watchedStates(timer, snapshot);
-        ready =
-            timer.kind === "idle_any"
-                ? states.some((s) => s.gone || (s.idle && s.since != null && s.since >= timer.created_at))
-                : states.length > 0 && states.every((s) => s.idle);
+        idleMet = idleConditionMet(timer, snapshot);
+        ready = idleMet;
         if (!ready)
             noteBlockedWatched(timer, snapshot, choices);
     }
     if (ready) {
+        await withPaneClaim(timer, async () => {
+            const decision = deliverable(timer, snapshot, choices);
+            if (!decision.ok || !claimOneShot(timer))
+                return false;
+            await deliver(timer, timedOut && !idleMet ? "max wait reached" : "", choices, decision.typedSeen, decision.firstHeldAt);
+            return true;
+        });
+    }
+}
+// A lead watch never enters the worker helpers below: it reads its own subscription row and the
+// watched lead's own turn record, and ends with a named reason rather than ever reading as idle.
+async function maybeFireLeadWatch(timer, sub, snapshot, now, choices) {
+    const timedOut = timer.max_wait_at != null && timer.max_wait_at <= now;
+    const readers = {
+        awaitingChoice: (pane, command) => awaitingChoice(pane, command, choices),
+        holdsInput: (pane, command) => inputBoxHoldsWake(pane, command, choices),
+    };
+    const result = evaluateLeadWatch(sub, timer.kind === "idle_all" ? "all" : "any", snapshot, readers);
+    const note = result.kind === "idle"
+        ? "watched lead's turn ended (not necessarily finished; read it before acting)"
+        : result.kind === "invalid"
+            ? `lead watch ended: ${result.reason}`
+            : timedOut
+                ? "max wait reached"
+                : null;
+    if (note === null)
+        return;
+    await withPaneClaim(timer, async () => {
         const decision = deliverable(timer, snapshot, choices);
-        if (decision.ok && claimOneShot(timer)) {
-            await deliver(timer, timedOut ? "max wait reached" : "", choices, decision.typedSeen, decision.firstHeldAt);
+        if (!decision.ok || !claimOneShot(timer))
+            return false;
+        if (result.kind === "invalid") {
+            bestEffortRun("UPDATE lead_idle_subscriptions SET terminal_reason = ? WHERE wake_id = ?", result.reason, timer.id);
         }
-    }
+        await deliver(timer, note, choices, decision.typedSeen, decision.firstHeldAt);
+        return true;
+    });
 }
 const TAIL_AGENTS = 3;
 function stateNowClause(agent) {
@@ -1546,7 +1715,8 @@ function watchedTail(timer) {
             }
             let tail = "";
             try {
-                tail = maskChoiceMarker(sanitizeTail(capturePane(agent.tmux_target, tailCaptureLines())));
+                const view = paneClassifierFor(agent.command)?.trailerView(agent.tmux_target) ?? null;
+                tail = maskChoiceMarker(view !== null ? renderTrailerView(view) : sanitizeTail(capturePane(agent.tmux_target, tailCaptureLines())));
             }
             catch {
             }

package/dist/spawn.js

@@ -16,6 +16,17 @@ export function withWindowClaim(claim) {
     }
     return db.transaction(claim).immediate();
 }
+export function storedLaunchOptions(value) {
+    if (value == null)
+        return { args: [], readOnly: false };
+    const stored = JSON.parse(value);
+    if (Array.isArray(stored))
+        return { args: stored, readOnly: false };
+    if (stored?.read_only === true && Array.isArray(stored.args)) {
+        return { args: stored.args, readOnly: true };
+    }
+    throw new Error("Invalid stored worker launch options");
+}
 export function splitTargetWindow(session, projectId, parentActor) {
     const parent = db
         .prepare("SELECT tmux_target, tmux_socket FROM agents WHERE actor_id = ? AND status = 'running' ORDER BY id DESC LIMIT 1")
@@ -30,7 +41,7 @@ export function splitTargetWindow(session, projectId, parentActor) {
 export function buildEnvFlags(env) {
     return Object.entries(env).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
 }
-function agentIdentityEnv(actorId, name, projectPath) {
+export function agentIdentityEnv(actorId, name, projectPath) {
     return {
         HIVE_AGENT_ID: actorId,
         HIVE_AGENT_NAME: name,
@@ -152,9 +163,11 @@ export function launchAgent(spec) {
     let info;
     try {
         info = db
-            .prepare("INSERT INTO agents (project_id, name, command, cwd, kind, parent_actor_id, tmux_socket, session_id, codex_home) " +
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
-            .run(spec.projectId, spec.name, typeof spec.commandString === "string" ? spec.commandString : "", spec.cwd, spec.kind, spec.parentActor, socket, spec.sessionId ?? "", spec.codexHome ?? "");
+            .prepare("INSERT INTO agents (project_id, name, command, cwd, kind, parent_actor_id, tmux_socket, session_id, codex_home, model, extra_args) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(spec.projectId, spec.name, typeof spec.commandString === "string" ? spec.commandString : "", spec.cwd, spec.kind, spec.parentActor, socket, spec.sessionId ?? "", spec.codexHome ?? "", spec.model ?? null, spec.readOnly
+            ? JSON.stringify({ args: spec.extraArgs ?? [], read_only: true })
+            : spec.extraArgs ? JSON.stringify(spec.extraArgs) : null);
     }
     catch (e) {
         throw asNameClash(e, spec.name);

package/dist/strictInput.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { noticeFor, releaseNotice } from "./result.js";
+import { noticeFor, releaseNotice, run } from "./result.js";
 function isBuiltSchema(value) {
     return typeof value === "object" && value !== null && ("_zod" in value || "_def" in value);
 }
@@ -51,6 +51,20 @@ function withStructuredContent(name, cb) {
         };
     };
 }
+function withCallGuard(name, cb, guard) {
+    return async (...args) => {
+        const input = (typeof args[0] === "object" && args[0] !== null ? args[0] : {});
+        try {
+            guard(name, input);
+        }
+        catch (e) {
+            return run(() => {
+                throw e;
+            });
+        }
+        return cb(...args);
+    };
+}
 function withNotice(result) {
     const notice = noticeFor(result);
     if (notice && result.structuredContent)
@@ -62,12 +76,15 @@ function withNoticeField(outputSchema) {
         ? outputSchema
         : { ...outputSchema, hive_notice: z.string().optional() };
 }
-export function enforceStrictInput(server) {
+export function enforceStrictInput(server, guard) {
     const register = server.registerTool.bind(server);
-    server.registerTool = ((name, config, cb) => register(name, {
-        ...config,
-        inputSchema: strictSchemaFor(name, config.inputSchema),
-        outputSchema: withNoticeField(config.outputSchema),
-    }, (config.outputSchema ? withStructuredContent(name, cb) : cb)));
+    server.registerTool = ((name, config, cb) => {
+        const guarded = guard ? withCallGuard(name, cb, guard) : cb;
+        return register(name, {
+            ...config,
+            inputSchema: strictSchemaFor(name, config.inputSchema),
+            outputSchema: withNoticeField(config.outputSchema),
+        }, (config.outputSchema ? withStructuredContent(name, guarded) : guarded));
+    });
     return server;
 }

package/dist/tmux.js

@@ -898,6 +898,52 @@ export function inputBoxState(target) {
         return null;
     }
 }
+const NOISE_ROW = /^[\s\u2500-\u257F\u2580-\u259F\u2800-\u28FF]*$/;
+const FOOTER_KEEP = /esc to interrupt|\d+ (?:shell|background|task|monitor|local agent|team)s?\b|remote dynamic workflow|cloud session|ultraplan needs your input/i;
+const OSC_SEQUENCE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const cleanRow = (row) => stripControlBytes(stripSgr(row.replace(OSC_SEQUENCE, ""))).trimEnd();
+function trailerRows(rows, from, to, keep) {
+    const out = [];
+    for (let i = from; i < to; i++) {
+        const row = cleanRow(rows[i]);
+        if (NOISE_ROW.test(row))
+            continue;
+        if (keep !== null && !keep.test(row))
+            continue;
+        out.push(row.slice(0, TAIL_LINE_CHARS));
+    }
+    return out;
+}
+export function renderTrailerView(view) {
+    const { box } = view;
+    const boxLine = box.state === "empty"
+        ? "input box: empty"
+        : box.state === "ghost"
+            ? "input box: empty (a model suggestion is showing; nobody typed it)"
+            : box.state === "pending"
+                ? `input box: UNSUBMITTED TEXT, not sent: "${box.text}"`
+                : "input box: could not be classified";
+    return [...view.above.slice(-TAIL_LINES), boxLine, ...view.below].join("\n");
+}
+export function claudeTrailerView(target) {
+    try {
+        const rows = tmux("capture-pane", "-p", "-e", "-t", target, "-S", `-${tailCaptureLines()}`).split("\n");
+        const anchor = findInputBox(rows);
+        if (anchor === null)
+            return null;
+        const box = anchor.prompt === null ? { state: "unknown", text: "" } : classifyInputBox(rows, anchor.prompt, anchor.bottom);
+        if (box.state === "unknown")
+            return null;
+        return {
+            above: trailerRows(rows, 0, anchor.top, null),
+            box,
+            below: trailerRows(rows, anchor.bottom + 1, rows.length, FOOTER_KEEP),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 const CHOICE_DIALOG = /Esc to cancel|ctrl\+g to edit in/;
 const isAwaitingChoiceScreen = (tail, wide) => CHOICE_DIALOG.test(tail) && !inputBoxOnScreen(wide);
 export const paneHasInputBox = (target) => {
@@ -1056,6 +1102,25 @@ export function codexInputBoxState(target) {
         return null;
     }
 }
+export function codexTrailerView(target) {
+    try {
+        const rows = tmux("capture-pane", "-p", "-e", "-t", target, "-S", `-${tailCaptureLines()}`).split("\n");
+        const anchor = findCodexPromptBox(rows);
+        if (anchor === null)
+            return null;
+        const box = classifyCodexInputBox(rows, anchor.prompt, anchor.footer);
+        if (box.state === "unknown")
+            return null;
+        return {
+            above: trailerRows(rows, 0, anchor.prompt, null),
+            box,
+            below: trailerRows(rows, anchor.footer, rows.length, FOOTER_KEEP),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export const codexPaneHasInputBox = (target) => {
     try {
         return codexInputBoxOnScreen(capturePane(target, tailCaptureLines()));