@cmgmyr/hive 1.3.0 → 1.5.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
@@ -1474,10 +1602,13 @@ 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;
     }
@@ -1497,12 +1628,44 @@ async function maybeFireIdle(timer, snapshot, now, choices) {
             noteBlockedWatched(timer, snapshot, choices);
     }
     if (ready) {
-        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, 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))
+            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) {
     if (!reportsAgentStateLog(agent))
@@ -1552,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/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) => {
@@ -972,7 +1018,8 @@ export function paneChoiceCheck(target) {
 // codex has no box border to anchor on, so the box's bottom edge used to be inferred from the literal
 // text of its footer status line - but that text is not stable (todo 524: two different compositions
 // seen on one codex version, one with no shared substring at all). The anchor below reads structure
-// instead of content: the pane's own last non-blank row IS the bottom edge, whatever it says.
+// instead of content: the pane's own last non-blank row IS the bottom edge, whatever it says, except that a
+// "? for shortcuts" row or a right-aligned footer row pulls the edge up to the status row above it.
 // codex's own choice-menu shape (see hive-internals), not claude's CHOICE_DIALOG wording. Declared
 // above findCodexPromptBox because the box search itself now needs it to reject a choice row rather
 // than mistake it for a live prompt.
@@ -991,6 +1038,7 @@ function codexPromptContentStart(promptRow) {
         i += 1;
     return i;
 }
+const CODEX_SHORTCUTS_ROW = /^\?\s+for shortcuts/;
 function findCodexPromptBox(rows) {
     const text = rows.map((row) => stripControlBytes(stripSgr(row)).trim());
     let footer = text.length - 1;
@@ -998,6 +1046,17 @@ function findCodexPromptBox(rows) {
         footer -= 1;
     if (footer < 0)
         return null;
+    // The row directly above "? for shortcuts" starts one footer block if it has codex's " · " status separator.
+    if (CODEX_SHORTCUTS_ROW.test(text[footer]) && footer > 0 && text[footer - 1].includes(" · "))
+        footer -= 1;
+    else if (footer > 0 && text[footer - 1].includes(" · ")) {
+        const footerRow = stripControlBytes(stripSgr(rows[footer]));
+        const footerContent = footerRow.trim();
+        const leadingWhitespace = footerRow.length - footerRow.trimStart().length;
+        // Use the row's geometry so this remains independent of whatever Codex writes in its footer.
+        if (leadingWhitespace > footerContent.length)
+            footer -= 1;
+    }
     let prompt = -1;
     for (let i = footer - 1; i >= 0 && footer - i <= BOX_MAX_ROWS; i--) {
         // The arrow ALONE, against the trimmed row: capture-pane strips a trailing space, and a box with
@@ -1016,12 +1075,10 @@ function findCodexPromptBox(rows) {
     // stale submitted prompt that also starts with "›").
     if (CODEX_CHOICE_LINE.test(text[prompt]))
         return null;
-    // Nothing but the prompt's own continuation, then one blank gap, may sit between the prompt row and
-    // the footer. Real content in that gap means the "›" found above is stale scrollback, not the live
-    // box - a busy/mid-turn screen can have an old prompt sitting within BOX_MAX_ROWS of whatever text
-    // is currently at the bottom, and only this check tells the two apart (see hive-internals).
+    // Only indented continuation rows, then one blank gap, may sit between the prompt and footer.
+    // Left-aligned output in that gap means the prompt is stale, not a live box (see hive-internals).
     let i = prompt + 1;
-    while (i <= footer && text[i] !== "")
+    while (i <= footer && text[i] !== "" && /^\s/.test(stripControlBytes(stripSgr(rows[i]))))
         i += 1;
     while (i <= footer && text[i] === "")
         i += 1;
@@ -1056,6 +1113,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()));

package/dist/tools/agents.js

@@ -2,6 +2,8 @@ import { existsSync, rmSync, statSync, realpathSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { db } from "../db.js";
+import { confirmQueenWrite } from "../queenAudit.js";
+import { captureQueenWriteIdentity } from "../context.js";
 import { agentBriefPath, mergedBriefVars, readAgentBrief, workerBrief, workerCommandString, writeAgentBrief, } from "../brief.js";
 import { codexHomeDir, codexInstructionsPhrase, codexLaunchArgs, ensureCodexHome, ensureCodexHooksFile, refreshCodexMcpEnv } from "../codexHome.js";
 import { currentActor, findProjectForDir, getProject, linkedWorktreePrimaryRoot, resolveProject } from "../context.js";
@@ -1067,6 +1069,7 @@ export function registerAgents(server) {
         const agent = findAgent(project.id, args);
         requireLive(agent);
         const target = agent.tmux_target;
+        const auditIdentity = captureQueenWriteIdentity(project.id);
         let outgoing = args.text ?? "";
         const tag = senderTag(project.id, currentActor());
         let shortened = null;
@@ -1210,6 +1213,7 @@ export function registerAgents(server) {
                         : `That target is a LEAD session, so agent_send's keys path is refused against it from a non-lead caller: you cannot finish this yourself. A human at that terminal, or another lead, has to press Enter there. Leave it and try again later.${shortened === null ? "" : " Pressing Enter there is the INTENDED finish, not a stray paste: that stranded line is hive's own pointer, and submitting it is exactly what this send was supposed to do."}`) +
                     shortenedClause, { cause: err });
             }
+            confirmQueenWrite("agent_send", project.id, args, { sent: true, agent_id: agent.id }, auditIdentity);
         }
         else {
             throw new Error("Pass text or keys.");

package/dist/tools/leases.js

@@ -18,7 +18,7 @@ export function extendOwnedLease(projectId, key, actor, ttlSeconds) {
 }
 export function registerLeases(server) {
     server.registerTool("lease_acquire", {
-        description: "Try to take a named lease on a shared work area (non-blocking). Re-taking your own lease extends it. Leases expire on their own.",
+        description: "Try to take a named lease on state another session could also change, such as a shared checkout, a dev database or a port (non-blocking). Re-taking your own lease extends it. Leases expire on their own.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -26,7 +26,7 @@ export function registerLeases(server) {
             openWorldHint: false,
         },
         inputSchema: {
-            key: z.string().describe('Stable and specific, like "file:src/api/routes.ts".'),
+            key: z.string().describe('Stable and specific, like "db:dev".'),
             ttl_seconds: z.number().int().positive(),
             project_id: projectIdParam,
         },

package/dist/tools/meta.js

@@ -1,33 +1,29 @@
 import { z } from "zod";
 import { db } from "../db.js";
-import { addProject, currentActor, listProjects, resolveProject, selectProjectById, TOUCH_INTERVAL_MS, trySelectedProject, } from "../context.js";
+import { addProject, currentActor, listProjects, findProjectForCwd, resolveProject, selectProjectById, TOUCH_INTERVAL_MS, trySelectedProject, } from "../context.js";
+import { confirmQueenWrite } from "../queenAudit.js";
 import { errorMessage, run } from "../result.js";
 import { HELP_TOPICS, helpOverview } from "../help.js";
 import { idParam } from "./params.js";
+import { formatRowCounts, PROJECT_OWNER_TABLES, projectRowCounts, removeProject } from "../projectRemove.js";
 function refuseIfLocked(tool) {
     if (process.env.HIVE_PROJECT_LOCK === "1") {
         throw new Error(`${tool} sweeps the whole store, across every project and every actor. This session is locked to one project (HIVE_PROJECT_LOCK=1) and cannot run it. Run it from an unlocked session (a lead).`);
     }
 }
-export const PROJECT_OWNER_TABLES = [
-    "pads",
-    "todos",
-    "kv",
-    "leases",
-    "agents",
-    "wakes",
-    "command_trust",
-];
 function existsWhere(table, column, value) {
     return db.prepare(`SELECT 1 FROM ${table} WHERE ${column} = ? LIMIT 1`).get(value) !== undefined;
 }
 function projectOwnsRows(projectId) {
     return PROJECT_OWNER_TABLES.some((table) => existsWhere(table, "project_id", projectId));
 }
-const pruneProjectIfEmpty = db.transaction((projectId) => {
-    if (projectOwnsRows(projectId))
+const pruneProjectIfEmpty = db.transaction((project) => {
+    if (projectOwnsRows(project.id))
+        return false;
+    if (db.prepare("DELETE FROM projects WHERE id = ?").run(project.id).changes === 0)
         return false;
-    return db.prepare("DELETE FROM projects WHERE id = ?").run(projectId).changes > 0;
+    confirmQueenWrite("project_prune", project.id, {}, { project_id: project.id, name: project.name });
+    return true;
 });
 export const ACTOR_OWNER_COLUMNS = [
     ["agents", "actor_id"],
@@ -143,29 +139,65 @@ export function registerMeta(server) {
         inputSchema: { project_id: idParam },
     }, ({ project_id }) => run(() => selectProjectById(project_id)));
     server.registerTool("project_prune", {
-        description: "Delete every registered project that owns no rows anywhere in the store (pads, todos, kv, leases, agents, wakes, command_trust), verified individually before each delete. Never prunes the caller's own project. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep, and a project-locked session may only touch its own project. Immediate, permanent: no dry-run mode.",
+        description: "Delete every registered project that owns no rows anywhere in the store (pads, todos, kv, leases, agents, wakes, command_trust), verified individually before each delete. Never prunes the caller's own project. With project_id, removes exactly that one project instead of sweeping, and only if it owns no rows; otherwise refuses and names what it owns. With project_id AND confirm_name (the project's exact name), removes that one project even when it owns rows: it takes a snapshot first, refuses while the project has a running agent, then deletes the project with everything it owns (todos, comments, pads, kv, leases, agents, wakes, trust, agent messages) in one transaction and reports per-table counts and the snapshot path. queen_audit rows naming it are kept, and so are other projects' lead-idle subscriptions that target it, so a watch on its lead ends with a named reason. confirm_name without project_id is refused, and there is no forced sweep. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep, and a project-locked session may only touch its own project. Immediate, permanent: no dry-run mode.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: true,
             idempotentHint: true,
             openWorldHint: false,
         },
-        inputSchema: {},
+        inputSchema: { project_id: idParam.optional(), confirm_name: z.string().optional() },
         outputSchema: {
             deleted: z.array(z.object({ id: idParam, name: z.string() })),
             held_back: z.object({ project_id: idParam, reason: z.string() }),
             errors: z.array(z.object({ id: idParam, name: z.string(), error: z.string() })).optional(),
+            counts: z.record(z.string(), z.number()).optional(),
+            snapshot: z.string().nullable().optional(),
         },
-    }, () => run(() => {
+    }, ({ project_id, confirm_name }) => run(() => {
         refuseIfLocked("project_prune");
         const homeId = resolveProject().id;
+        const cwdId = findProjectForCwd()?.id;
+        const isOwn = (id) => id === homeId || id === cwdId;
+        if (confirm_name !== undefined && project_id === undefined) {
+            throw new Error("project_prune: confirm_name needs project_id; there is no forced sweep.");
+        }
+        if (project_id !== undefined) {
+            if (isOwn(project_id))
+                throw new Error(`project_prune: project ${project_id} is the caller's own project and is never pruned.`);
+            const target = listProjects().find((p) => p.id === project_id);
+            if (!target)
+                throw new Error(`project_prune: no project ${project_id}. List them with project_list.`);
+            if (confirm_name !== undefined) {
+                if (confirm_name !== target.name) {
+                    throw new Error(`project_prune: confirm_name does not match project ${project_id}, whose name is "${target.name}". Nothing deleted.`);
+                }
+                const removed = removeProject(project_id, {
+                    snapshot: true,
+                    onRemoved: (r) => confirmQueenWrite("project_prune", project_id, {}, { project_id, name: r.deleted.name, counts: r.counts }),
+                });
+                return {
+                    deleted: [{ id: removed.deleted.id, name: removed.deleted.name }],
+                    held_back: { project_id: homeId, reason: "caller's own project" },
+                    counts: removed.counts,
+                    snapshot: removed.snapshot,
+                };
+            }
+            if (!pruneProjectIfEmpty.immediate(target)) {
+                throw new Error(`project_prune: project ${project_id} ("${target.name}") is not empty, nothing deleted. It owns ${formatRowCounts(projectRowCounts(project_id))}. To remove it with everything it owns, pass confirm_name with its exact name.`);
+            }
+            return {
+                deleted: [{ id: target.id, name: target.name }],
+                held_back: { project_id: homeId, reason: "caller's own project" },
+            };
+        }
         const deleted = [];
         const errors = [];
         for (const project of listProjects()) {
-            if (project.id === homeId)
+            if (isOwn(project.id))
                 continue;
             try {
-                if (pruneProjectIfEmpty.immediate(project.id)) {
+                if (pruneProjectIfEmpty.immediate(project)) {
                     deleted.push({ id: project.id, name: project.name });
                 }
             }
@@ -180,7 +212,7 @@ export function registerMeta(server) {
         };
     }));
     server.registerTool("actor_prune", {
-        description: "Delete every actor that owns no rows anywhere in the store and has not been active in the last minute: agents.actor_id, agents.parent_actor_id, todos.locked_by, todo_comments.author, kv.updated_by, leases.owner, pads.updated_by, wakes.owner, wakes.deliver_actor, agent_state_log.actor_id. The scan is global across every project, never scoped to the caller's: actors carry no project_id, so an actor can own rows in a project the caller cannot see, and a project-scoped scan would misread that actor as inert and delete it. Never prunes the caller's own actor. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep. Run this after project_prune when sweeping the store: an empty project owns no agents rows either, so today the order cannot orphan an actor, but that stops being true the day project deletion ever covers a non-empty project, and this ordering is the one that stays safe if it does. Immediate, permanent: no dry-run mode.",
+        description: "Delete every actor that owns no rows anywhere in the store and has not been active in the last minute: agents.actor_id, agents.parent_actor_id, todos.locked_by, todo_comments.author, kv.updated_by, leases.owner, pads.updated_by, wakes.owner, wakes.deliver_actor, agent_state_log.actor_id. The scan is global across every project, never scoped to the caller's: actors carry no project_id, so an actor can own rows in a project the caller cannot see, and a project-scoped scan would misread that actor as inert and delete it. Never prunes the caller's own actor. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep. Run this after project_prune when sweeping the store: project_prune with confirm_name removes a non-empty project together with its agents rows, so run this afterwards to clear that project's actors that own nothing else. Actors with agent_state_log rows stay, because that log is append-only and has no project, which means every actor that ever ran a lead or worker stays. Immediate, permanent: no dry-run mode.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: true,

package/dist/tools/queenAudit.js

@@ -0,0 +1,13 @@
+import { listQueenAudit } from "../queenAudit.js";
+import { run } from "../result.js";
+import { idParam, limitParam } from "./params.js";
+export function registerQueenAudit(server) {
+    server.registerTool("queen_audit_list", {
+        description: "List confirmed queen writes into other projects, newest first. The queen may read all targets; other callers see only their own project. Default 20, maximum 100 entries. History is retained for 30 days with a 20,000 id-range backstop. A crash between a completed terminal send and its audit insert can leave that send unrecorded.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: {
+            project_id: idParam.optional().describe("Filter by the target project id. Only the queen may name another project."),
+            limit: limitParam,
+        },
+    }, (args) => run(() => listQueenAudit(args)));
+}