@cmgmyr/hive 1.3.0 → 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
@@ -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) => {
@@ -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()));

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

@@ -24,6 +24,12 @@ function existsWhere(table, column, value) {
 function projectOwnsRows(projectId) {
     return PROJECT_OWNER_TABLES.some((table) => existsWhere(table, "project_id", projectId));
 }
+function ownedRowCounts(projectId) {
+    return PROJECT_OWNER_TABLES.flatMap((table) => {
+        const n = db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE project_id = ?`).get(projectId).n;
+        return n > 0 ? [`${table}: ${n}`] : [];
+    });
+}
 const pruneProjectIfEmpty = db.transaction((projectId) => {
     if (projectOwnsRows(projectId))
         return false;
@@ -143,22 +149,36 @@ 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. 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() },
         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(),
         },
-    }, () => run(() => {
+    }, ({ project_id }) => run(() => {
         refuseIfLocked("project_prune");
         const homeId = resolveProject().id;
+        if (project_id !== undefined) {
+            if (project_id === homeId)
+                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 (!pruneProjectIfEmpty.immediate(project_id)) {
+                throw new Error(`project_prune: project ${project_id} ("${target.name}") is not empty, nothing deleted. It owns ${ownedRowCounts(project_id).join(", ")}.`);
+            }
+            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()) {

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)));
+}

package/dist/tools/todos.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { db } from "../db.js";
+import { commitQueenStateWrite } from "../queenAudit.js";
 import { currentActor, effectiveProjectId, resolveProject } from "../context.js";
 import { matchesAnyTag, parseTags, run } from "../result.js";
 import { findUnsafeControlChar } from "../tmux.js";
@@ -220,14 +221,16 @@ export function registerTodos(server) {
     }, (args) => run(() => {
         const projectId = effectiveProjectId(args.project_id);
         currentActor();
-        const info = db
-            .prepare("INSERT INTO todos (project_id, title, body, priority, tags, slug) VALUES (?, ?, ?, ?, ?, ?)")
-            .run(projectId, args.title, args.body ?? "", args.priority ?? "medium", JSON.stringify(args.tags ?? []), args.slug ?? "");
-        const todoId = Number(info.lastInsertRowid);
-        for (const blockerId of args.blocked_by ?? []) {
-            addBlocker.immediate(projectId, todoId, blockerId);
-        }
-        return { project_id: projectId, todo_id: todoId };
+        return commitQueenStateWrite("todo_create", projectId, args, () => {
+            const info = db
+                .prepare("INSERT INTO todos (project_id, title, body, priority, tags, slug) VALUES (?, ?, ?, ?, ?, ?)")
+                .run(projectId, args.title, args.body ?? "", args.priority ?? "medium", JSON.stringify(args.tags ?? []), args.slug ?? "");
+            const todoId = Number(info.lastInsertRowid);
+            for (const blockerId of args.blocked_by ?? []) {
+                addBlocker.immediate(projectId, todoId, blockerId);
+            }
+            return { project_id: projectId, todo_id: todoId };
+        });
     }));
     server.registerTool("todo_list", {
         description: "List todo summaries. is_blocked=false finds dispatchable work. query matches title, body, and slug. Archived todos are excluded by default; include_archived=true retrieves them too.",
@@ -374,11 +377,13 @@ export function registerTodos(server) {
     }, (args) => run(() => {
         const projectId = effectiveProjectId(args.project_id);
         const todo = getTodo(projectId, args.todo_id);
-        const info = db
-            .prepare("INSERT INTO todo_comments (todo_id, author, body) VALUES (?, ?, ?)")
-            .run(todo.id, currentActor(), args.body);
-        touch(todo.id);
-        return { project_id: projectId, todo_id: todo.id, comment_id: Number(info.lastInsertRowid) };
+        return commitQueenStateWrite("todo_comment", projectId, args, () => {
+            const info = db
+                .prepare("INSERT INTO todo_comments (todo_id, author, body) VALUES (?, ?, ?)")
+                .run(todo.id, currentActor(), args.body);
+            touch(todo.id);
+            return { project_id: projectId, todo_id: todo.id, comment_id: Number(info.lastInsertRowid) };
+        });
     }));
     server.registerTool("todo_block", {
         description: "Add a blocker: todo_id cannot start until blocker_id completes. Cycles are rejected.",