@cmgmyr/hive 1.11.3 → 1.11.5

package/dist/abi.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { cliPath, dispatcherPath, readDispatcher } from "./dispatcher.js";
+import { cliPath, dispatcherPath, readDispatcher, repinCommand } from "./dispatcher.js";
 const requireFromHere = createRequire(import.meta.url);
 export function classifyAddonLoadError(error) {
     return /NODE_MODULE_VERSION \d+|Module did not self-register/i.test(error) ? "mismatch" : "load";
@@ -129,7 +129,7 @@ export function abiFixLines(status, pinned) {
     if (status.failure === "napi") {
         const need = status.nodeApiRequired;
         const range = need === null ? null : nodeRangeForNodeApi(need);
-        const good = pinned ? `"${pinned}"` : `<a Node matching ${range ?? "that Node-API level"}>`;
+        const good = pinned ?? `<a Node matching ${range ?? "that Node-API level"}>`;
         return [
             `better-sqlite3's addon is built against Node-API ${need}${range ? `, which only Node ${range} provides` : ""}.`,
             `This interpreter provides Node-API ${describeNodeApi(status.nodeApi)}, so the addon cannot load here.`,
@@ -141,7 +141,7 @@ export function abiFixLines(status, pinned) {
             "",
             `Run hive under a Node matching ${range ?? "that Node-API level"}, and re-pin the \`hive\` command`,
             "to it (setup pins whatever Node runs it, so it has to be that one):",
-            `  ${good} "${cliPath()}" setup`,
+            `  ${repinCommand(good, cliPath())}`,
         ];
     }
     if (status.failure === "missing") {
@@ -164,7 +164,7 @@ export function abiFixLines(status, pinned) {
     if (status.failure !== "mismatch") {
         return ["Build it:  npm install && npm run build"];
     }
-    const good = pinned ? `"${pinned}"` : "<the Node that built it>";
+    const good = pinned ?? "<the Node that built it>";
     return [
         "better-sqlite3's addon is ABI-locked to the Node that compiled it, and a Node",
         "version manager resolves `node` from the working directory, so a `cd` is enough",
@@ -172,10 +172,12 @@ export function abiFixLines(status, pinned) {
         "",
         "Run hive under the Node it was built for, and re-pin the `hive` command to it",
         "(setup pins whatever Node runs it, so it has to be that one):",
-        `  ${good} "${cliPath()}" setup`,
+        `  ${repinCommand(good, cliPath())}`,
         "",
-        "Or rebuild the addon for the Node you are on, and re-pin to that:",
-        "  npm install && npm run build && hive setup",
+        "Rebuilding is not the fix for the supported addon. Update hive, then re-pin this CLI:",
+        "  Global install: npm install -g @cmgmyr/hive",
+        "  Checkout: npm install && npm run build",
+        `  ${repinCommand(good, cliPath())}`,
     ];
 }
 function workingInterpreterFromDispatcher() {

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.11.3","sha":"959b92c","dirty":false,"build_id":"9ec08cbe1418fce5591b6a2d0373e6bd5173810edd4f572aa06bdd23e49bdd11"}
+{"version":"1.11.5","sha":"486161d","dirty":false,"build_id":"3a33da919c1ac52f423bfdb530cfeda01207921e9c0fb8b262462fae1c266b12"}

package/dist/cli.js

@@ -3,14 +3,14 @@ import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join, resolve, sep } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { pathToFileURL } from "node:url";
 import { checkAbi, describeAbi, describeInterpreter, nodeRangeForNodeApi, requiredNodeApi } from "./abi.js";
 import { versionInfo } from "./version.js";
 import { claudeConfigDir } from "./claudeDir.js";
 import { ATTACH_MODES, AUTO_ATTACH_MODES, attachMode, isAttachMode, isAutoAttach, migrateLegacyConfig, resolvedAutoAttach, setAttachMode, setAutoAttach, } from "./config.js";
-import { cliPath, dispatcherDir, dispatcherPath, dispatcherScript, durabilityLines, firstHiveOnPath, linkedWorktreePin, pathAdvice, readDispatcher, } from "./dispatcher.js";
+import { cliPath, dispatcherDir, dispatcherPath, dispatcherScript, durabilityLines, firstHiveOnPath, linkedWorktreePin, pathAdvice, repinCommand, readDispatcher, } from "./dispatcher.js";
 import { codexConfigPath, codexHiveRegistrations, codexRegistrationProblem, hiveRegistrations, registrationOffer, registrationProblem, } from "./mcpConfig.js";
 import { DEFAULT_DATA_DIR, storeDir } from "./dataDir.js";
 import { dataDir, db, migrate, storeSchemaAhead } from "./db.js";
@@ -36,7 +36,7 @@ import { asNameClash, buildEnvFlags, closeAgentRow, isReservedAgentName, launchA
 import { adoptableWindow, applyLayout, claimInitialWindow, configureHiveWindow, controlModeFor, createWindow, DEFAULT_LAYOUT, describePaneChoice, ensureSession, findProjectWindow, foreignSocket, isViewSessionName, listOwnedWindows, liveTargets, observationFailed, observeRowOwnership, ORPHAN_MIN_AGE_MS, orphanScratchServers, orphansWorthWarningAbout, paneIsAloneInWindow, paneVisibility, panePidForRecord, PROCESSES_LAYOUT, processesPaneTitle, processesWindowName, projectWindows, RAW_ATTACH_TMUX_CONFIG, renderAttachCommand, resolveAttachTarget, resolveInTmuxTarget, rowLive, rowOwnership, SESSION_PREFIX, appendGlobalHook, globalHooks, replaceGlobalHooks, sessionName, setPaneTitle, shellQuote, shownPaneTitle, makeProcessesWindow, tmux, TMUX_DOC, tmuxSaysNothingThere, tmuxTimeoutOverride, tmuxSocketPath, untrustedTmuxServer, waitForPaneEstablished, windowLayout, } from "./tmux.js";
 import { collectCrew, crewStoreProblem } from "./crew.js";
 import { describeVisibility, formatLocal, processCounts } from "./dashboard.js";
-import { runningCommandRow, runningCommandRows, snapshotProcesses, stopAllProcesses, stopLine, stopProcess, STOP_REASONS, } from "./processes.js";
+import { runningCommandRow, runningCommandRows, snapshotProcesses, stopAllProcesses, stopLine, stopProcess, renderStart, STOP_REASONS, } from "./processes.js";
 import { activeProfile, agentVarKeys, BUILT_IN_PROJECT_YML, configHash, loadProjectYml, mergedProjectVars, NO_PROFILE, PROJECT_YML_KEYS, resolveCommandDir, resolveFirstMessage, } from "./projectYml.js";
 import { appendClaudeLeadArgs, crewPluginDir, isTrusted, leadIdentityEnv, renderLeadPosture } from "./leadLaunch.js";
 import { handoffStatusSegment } from "./leadHandoff.js";
@@ -47,7 +47,8 @@ import { FIRST_MESSAGE_SHA_ENV, firstMessageDigest } from "./firstMessage.js";
 import { ageSecondsSince, deriveProvenance, describeForHuman, describeLastLogEvent, humanizeAge, lastLogEvent, lastPermissionMode, reportsAgentStateLog, } from "./stateProvenance.js";
 import { awaitingFirstPromptSql } from "./firstPrompt.js";
 import { checkoutRoot, createProfile, forkProfile, PROFILE_FILES, ProfileError, profileExists, profileFileNames, profileNames, profileStatus, readProfileFile, referencedPads, referencedPaths, renderProfileFile, resolveProfileFile, REWRITE_THRESHOLD, templateVars, userProfilesDir, } from "./profiles.js";
-import { getTodoDetail, listTodoSummaries, OPEN_BLOCKERS_SQL, TODO_STATUSES, } from "./tools/todos.js";
+import { getTodoDetail, listTodoSummaries, TODO_STATUSES, } from "./tools/todos.js";
+import { ACTIVE_TODO_SQL, OPEN_BLOCKERS_SQL } from "./todoScope.js";
 import { createPad, getActivePadByName, listActivePads, overwritePadContent, } from "./tools/pads.js";
 import { answerQuestion, listQuestions } from "./questions.js";
 function usage() {
@@ -213,9 +214,15 @@ async function ensureTrusted(projectId, name, command, dir, env) {
     db.prepare("INSERT OR IGNORE INTO command_trust (project_id, name, config_hash) VALUES (?, ?, ?)").run(projectId, name, hash);
     return true;
 }
-function startYmlCommand(project, name, proc, config) {
+function startYmlCommand(project, name, proc, config, trusted) {
+    if (!trusted)
+        return { status: "refused", reason: "untrusted" };
     if (isReservedAgentName(name)) {
-        return `skipped: "lead" is reserved for this project's lead session and cannot be used as a process name`;
+        return {
+            status: "refused",
+            reason: "reserved-name",
+            message: `skipped: "lead" is reserved for this project's lead session and cannot be used as a process name`,
+        };
     }
     const existing = db
         .prepare("SELECT id, tmux_target, tmux_socket FROM agents WHERE project_id = ? AND name = ? AND status = 'running'")
@@ -225,10 +232,15 @@ function startYmlCommand(project, name, proc, config) {
         if (live) {
             const windows = projectWindows(sessionName(), project.id);
             const where = windows === null ? null : paneVisibility(existing.tmux_target, windows);
-            return where === "shown" || where === "hidden" ? `already running (${where})` : "already running";
+            return { status: "already-running", location: where === "shown" || where === "hidden" ? where : null };
+        }
+        if (live === null) {
+            return {
+                status: "refused",
+                reason: "unknown-liveness",
+                message: "skipped: tmux could not be probed, so hive cannot tell whether it is already running",
+            };
         }
-        if (live === null)
-            return "skipped: tmux could not be probed, so hive cannot tell whether it is already running";
         closeAgentRow(existing.id);
     }
     let dir;
@@ -236,7 +248,7 @@ function startYmlCommand(project, name, proc, config) {
         dir = resolveCommandDir(project.path, proc.dir);
     }
     catch (e) {
-        return `skipped: ${errorMessage(e)}`;
+        return { status: "refused", reason: "escaped-dir", message: `skipped: ${errorMessage(e)}` };
     }
     const placement = proc.visible
         ? (config.placement ?? (process.env.HIVE_SPAWN_PLACEMENT === "window" ? "window" : "split"))
@@ -260,17 +272,20 @@ function startYmlCommand(project, name, proc, config) {
             setPaneTitle(target, shownPaneTitle(project.name, name));
             if (landedInProjectId != null) {
                 const landedName = getProject(landedInProjectId)?.name ?? `project ${landedInProjectId}`;
-                return `started, landed in project "${landedName}"'s window`;
+                return { status: "started", message: `started, landed in project "${landedName}"'s window` };
             }
-            return "started";
+            return { status: "started", message: "started" };
         }
-        return inProcessesWindow
-            ? "started (hidden)"
-            : "started in its own window: it opened this project's tmux session, and a session's first window " +
-                `cannot be a tile. Move it with: hive hide "${name}"`;
+        return {
+            status: "started",
+            message: inProcessesWindow
+                ? "started (hidden)"
+                : "started in its own window: it opened this project's tmux session, and a session's first window " +
+                    `cannot be a tile. Move it with: hive hide "${name}"`,
+        };
     }
     catch (e) {
-        return `failed: ${errorMessage(e)}`;
+        return { status: "failed", message: errorMessage(e) };
     }
 }
 function attach(session, project, window) {
@@ -636,9 +651,10 @@ async function cmdLead(argv) {
                     console.log(`- ${name}: defined, auto_start off (start with: hive start "${name}")`);
                     continue;
                 }
-                if (await ensureTrusted(project.id, name, proc.command, proc.dir, proc.env)) {
-                    console.log(`- ${name}: ${startYmlCommand(project, name, proc, config)}`);
-                }
+                const trusted = await ensureTrusted(project.id, name, proc.command, proc.dir, proc.env);
+                const result = startYmlCommand(project, name, proc, config, trusted);
+                if (trusted)
+                    console.log(`- ${name}: ${renderStart(result)}`);
             }
         }
         if (registrationNotice) {
@@ -1366,9 +1382,12 @@ async function cmdStart(argv) {
         console.log(processNotDefined(config, name));
         process.exit(1);
     }
-    if (await ensureTrusted(project.id, name, proc.command, proc.dir, proc.env)) {
-        console.log(`${name}: ${startYmlCommand(project, name, proc, config)}`);
-    }
+    const trusted = await ensureTrusted(project.id, name, proc.command, proc.dir, proc.env);
+    const result = startYmlCommand(project, name, proc, config, trusted);
+    if (trusted)
+        console.log(`${name}: ${renderStart(result)}`);
+    if (!trusted || result.status === "failed" || result.status === "refused")
+        process.exitCode = 1;
 }
 function processNotDefined(config, name) {
     const known = Object.keys(config?.processes ?? {});
@@ -1631,7 +1650,7 @@ function cmdStatus() {
             .prepare("SELECT * FROM agents WHERE project_id = ? AND status = 'running' ORDER BY kind DESC, id")
             .all(project.id);
         const todos = db
-            .prepare("SELECT COUNT(*) AS n FROM todos WHERE project_id = ? AND status IN ('open', 'in_progress') AND archived_at IS NULL")
+            .prepare(`SELECT COUNT(*) AS n FROM todos t WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}`)
             .get(project.id).n;
         const { wakes, heldWakes } = db
             .prepare(`SELECT COUNT(*) AS wakes, COUNT(held_at) AS heldWakes FROM wakes WHERE project_id = ? AND ${ACTIVE_TIMER_WHERE}`)
@@ -1889,7 +1908,7 @@ function reportDispatcher() {
     }
     info("dispatcher", `${dispatcher.file} -> ${dispatcher.node ?? "an exec line hive cannot parse"}`);
     if (!dispatcher.node || !dispatcher.cli) {
-        gatingWarn("dispatcher", "written by another version of hive; re-run `hive setup` to refresh it.");
+        gatingWarn("dispatcher", "written by another version of hive; use this re-pin command to refresh it:", `  ${repinCommand(process.execPath, cliPath())}`);
     }
     else if (!existsSync(dispatcher.node)) {
         const need = requiredNodeApi();
@@ -1907,7 +1926,7 @@ function reportDispatcher() {
         gatingWarn("dispatcher", `pinned to a linked git worktree, which this repo tears down: ${dispatcher.cli}`, "A worktree teardown leaves `hive` failing with MODULE_NOT_FOUND, and running `hive setup`", "to repair it just re-pins the same worktree, since that shim is what runs the command.", `Re-pin from the durable checkout instead: "${dispatcher.node}" "${repairCli}" setup`);
     }
     else if (dispatcher.node !== process.execPath || dispatcher.cli !== cliPath()) {
-        gatingWarn("dispatcher", "pinned to a different build than this CLI is running.", `this run: ${process.execPath} ${cliPath()}`, "Re-pin after a rebuild: npm run build && hive setup");
+        gatingWarn("dispatcher", "pinned to a different build than this CLI is running.", `this run: ${process.execPath} ${cliPath()}`, `Re-pin after a rebuild: ${repinCommand(process.execPath, cliPath())}`);
     }
     if (onPath !== dispatcher.file)
         gatingWarn("dispatcher", ...pathAdvice(dispatcherDir(), dispatcher.file));
@@ -2005,8 +2024,12 @@ function reportPtyHeadroom(orphans) {
     const scratchHeld = orphans ? orphans.live + orphans.wedged : 0;
     const livePanes = db.prepare("SELECT COUNT(*) AS n FROM agents WHERE status = 'running'").get()
         .n;
-    warn("ptys", `${headroom.allocated} of ${headroom.max} in use (${free} free), below the safety margin${overrideNote}`, shellsLine, `${scratchHeld} orphaned scratch tmux server(s) still holding a socket (detail in the scratch tmux servers check)`, `${livePanes} pane(s) recorded 'running' in hive's own store (leads and workers, this machine)`, "reap the orphaned shells and scratch servers with `node scripts/sweep-scratch.mjs` (dry run by default, " +
-        "`--kill` to act)");
+    warn("ptys", `${headroom.allocated} of ${headroom.max} in use (${free} free), below the safety margin${overrideNote}`, shellsLine, `${scratchHeld} orphaned scratch tmux server(s) still holding a socket (detail in the scratch tmux servers check)`, `${livePanes} pane(s) recorded 'running' in hive's own store (leads and workers, this machine)`, ...(existsSync(join(dirname(cliPath()), "..", "scripts", "sweep-scratch.mjs"))
+        ? [
+            "reap the orphaned shells and scratch servers with `node scripts/sweep-scratch.mjs` (dry run by default, " +
+                "`--kill` to act)",
+        ]
+        : []));
 }
 function reportOrphanTmuxServers(orphans) {
     if (!orphans)
@@ -2765,9 +2788,9 @@ function cmdStatusline() {
     const count = (sql) => db.prepare(sql).get(project.id).n;
     const agents = count("SELECT COUNT(*) AS n FROM agents WHERE project_id = ? AND status = 'running' AND kind = 'agent'");
     const commands = count("SELECT COUNT(*) AS n FROM agents WHERE project_id = ? AND status = 'running' AND kind = 'command'");
-    const todos = count("SELECT COUNT(*) AS n FROM todos WHERE project_id = ? AND status IN ('open', 'in_progress') AND archived_at IS NULL");
+    const todos = count(`SELECT COUNT(*) AS n FROM todos t WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}`);
     const ready = count(`SELECT COUNT(*) AS n FROM todos t
-     WHERE t.project_id = ? AND t.status IN ('open', 'in_progress') AND t.archived_at IS NULL
+     WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}
        AND NOT EXISTS (${OPEN_BLOCKERS_SQL})`);
     const pads = count("SELECT COUNT(*) AS n FROM pads WHERE project_id = ? AND archived = 0");
     const wakes = count(`SELECT COUNT(*) AS n FROM wakes WHERE project_id = ? AND ${ACTIVE_TIMER_WHERE}`);

package/dist/codexHome.js

@@ -303,7 +303,6 @@ export function ensureCodexHome(input) {
         indexJs,
         serverEnv: { ...input.serverEnv, HIVE_AGENT_ID: input.actorId },
         statusLine,
-        readOnly: input.readOnly,
         modelContextWindow,
         modelAutoCompactTokenLimit,
     }));

package/dist/context.js

@@ -1,4 +1,3 @@
-import { execFileSync } from "node:child_process";
 import { lstatSync, realpathSync } from "node:fs";
 import { userInfo } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
@@ -7,6 +6,7 @@ import { db } from "./db.js";
 import { LEAD_KIND } from "./spawn.js";
 import { rowOwnership } from "./tmux.js";
 import { recordQueenRefusal } from "./queenAudit.js";
+import { gitOut } from "./git.js";
 let selectedId = null;
 let cachedActorId = null;
 let lastTouchMs = 0;
@@ -92,18 +92,13 @@ export function registeredAncestor(dir) {
     return bestPrefixMatch(projects, dir);
 }
 export function gitPrimaryRoot(dir) {
+    const commonDir = gitOut(dir, ["rev-parse", "--git-common-dir"]);
+    if (commonDir === null)
+        return null;
+    const resolvedCommonDir = resolve(dir, commonDir);
+    if (basename(resolvedCommonDir) !== ".git")
+        return null;
     try {
-        const { GIT_DIR: _gitDir, GIT_COMMON_DIR: _gitCommonDir, GIT_WORK_TREE: _gitWorkTree, ...env } = process.env;
-        const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
-            cwd: dir,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 2000,
-            env,
-        }).trim();
-        const resolvedCommonDir = resolve(dir, commonDir);
-        if (basename(resolvedCommonDir) !== ".git")
-            return null;
         return realpathSync(dirname(resolvedCommonDir));
     }
     catch {
@@ -111,19 +106,13 @@ export function gitPrimaryRoot(dir) {
     }
 }
 function gitDirs(dir) {
+    const result = gitOut(dir, ["rev-parse", "--git-dir", "--git-common-dir"]);
+    if (result === null)
+        return null;
+    const out = result.split("\n");
+    if (out.length !== 2)
+        return null;
     try {
-        const { GIT_DIR: _gitDir, GIT_COMMON_DIR: _gitCommonDir, GIT_WORK_TREE: _gitWorkTree, ...env } = process.env;
-        const out = execFileSync("git", ["rev-parse", "--git-dir", "--git-common-dir"], {
-            cwd: dir,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 2000,
-            env,
-        })
-            .trim()
-            .split("\n");
-        if (out.length !== 2)
-            return null;
         return {
             gitDir: realpathSync(resolve(dir, out[0])),
             commonDir: realpathSync(resolve(dir, out[1])),

package/dist/crew.js

@@ -1,15 +1,16 @@
-import { execFileSync } from "node:child_process";
 import { db } from "./db.js";
 import { isLinkedWorktree } from "./context.js";
 import { awaitingFirstPrompt } from "./firstPrompt.js";
 import { heldReasonLabel } from "./heldLabel.js";
 import { harnessFor, paneClassifierFor } from "./harnesses.js";
 import { NEEDS_HUMAN_TAG } from "./portfolio.js";
+import { ACTIVE_TODO_SQL } from "./todoScope.js";
 import { pendingQuestionCount } from "./questions.js";
 import { loadProjectYml } from "./projectYml.js";
 import { parseTags } from "./result.js";
 import { ACTIVE_TIMER_WHERE } from "./scheduler.js";
 import { reportsAgentStateLog } from "./stateProvenance.js";
+import { gitOut } from "./git.js";
 import { liveTargets, rowOwnership } from "./tmux.js";
 import { SKILL_TOOL, lastComponent, readContextFill, readRecentToolCalls, } from "./transcript.js";
 export function crewStoreProblem(database = db) {
@@ -50,36 +51,18 @@ function oneShotWatched(pending) {
         }
     });
 }
-function stripped(env) {
-    const { GIT_DIR: _gitDir, GIT_COMMON_DIR: _gitCommonDir, GIT_WORK_TREE: _gitWorkTree, ...rest } = env;
-    return rest;
-}
-function git(cwd, args) {
-    try {
-        return execFileSync("git", args, {
-            cwd,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 2000,
-            env: stripped(process.env),
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-}
 export function readCommitsAhead(cwd, projectRoot) {
     if (!cwd || cwd === projectRoot || !isLinkedWorktree(cwd))
         return null;
     const candidates = [];
-    const remoteHead = git(cwd, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+    const remoteHead = gitOut(cwd, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
     if (remoteHead)
         candidates.push(remoteHead);
     candidates.push("refs/heads/main", "refs/heads/master");
     for (const ref of candidates) {
-        if (git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]) === null)
+        if (gitOut(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]) === null)
             continue;
-        const count = git(cwd, ["rev-list", "--count", `${ref}..HEAD`]);
+        const count = gitOut(cwd, ["rev-list", "--count", `${ref}..HEAD`]);
         return count !== null && /^\d+$/.test(count) ? Number(count) : null;
     }
     return null;
@@ -481,7 +464,7 @@ export function collectCrew(project, now) {
         if (!staffed.has(todo.id))
             lanes.push({ todo, worker: null });
     const needsYou = db
-        .prepare("SELECT id, slug, tags FROM todos WHERE project_id = ? AND status != 'completed' AND archived_at IS NULL ORDER BY id")
+        .prepare(`SELECT t.id, t.slug, t.tags FROM todos t WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL} ORDER BY t.id`)
         .all(project.id)
         .filter((t) => parseTags(t.tags).includes(NEEDS_HUMAN_TAG))
         .map((t) => ({ id: t.id, slug: t.slug }));

package/dist/dashboard.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
 import { db } from "./db.js";
+import { ACTIVE_TODO_SQL, NOT_COMPLETED_TODO_SQL, OPEN_BLOCKERS_SQL } from "./todoScope.js";
 import { getProject } from "./context.js";
 export const describeVisibility = (visibility) => visibility === null ? "running" : visibility === "window" ? "own window" : visibility;
 export function processCounts(procs) {
@@ -127,12 +128,9 @@ function fetchNextWake(projectId) {
 function fetchTodoCounts(projectId) {
     return db
         .prepare(`SELECT
-         (SELECT COUNT(*) FROM todos WHERE project_id = ? AND archived_at IS NULL AND status != 'completed') AS open,
-         (SELECT COUNT(*) FROM todos t WHERE t.project_id = ? AND t.archived_at IS NULL AND t.status != 'completed'
-            AND EXISTS (
-              SELECT 1 FROM todo_blockers b JOIN todos bt ON bt.id = b.blocker_id
-               WHERE b.todo_id = t.id AND bt.status != 'completed'
-            )) AS blocked,
+         (SELECT COUNT(*) FROM todos t WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}) AS open,
+         (SELECT COUNT(*) FROM todos t WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}
+            AND EXISTS (${OPEN_BLOCKERS_SQL})) AS blocked,
          (SELECT COUNT(*) FROM todos
             WHERE project_id = ? AND completed_at IS NOT NULL
               AND date(completed_at, 'localtime') >= date('now', 'localtime', '-6 days')) AS completed7d`)
@@ -262,10 +260,9 @@ function renderBoardSection(index, projectId) {
 }
 const OPEN_TODOS_SQL = `
   SELECT t.id, t.title, t.body, t.slug, t.status, t.priority,
-    (SELECT COUNT(*) FROM todo_blockers b JOIN todos bt ON bt.id = b.blocker_id
-      WHERE b.todo_id = t.id AND bt.status != 'completed') AS open_blockers
+    EXISTS (${OPEN_BLOCKERS_SQL}) AS blocked
   FROM todos t
-  WHERE t.project_id = ? AND t.archived_at IS NULL AND t.status != 'completed'
+  WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}
   ORDER BY CASE t.priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 ELSE 2 END, t.id`;
 function fetchBlockersFor(todoIds) {
     const byTodo = new Map();
@@ -274,7 +271,7 @@ function fetchBlockersFor(todoIds) {
     const placeholders = todoIds.map(() => "?").join(",");
     const rows = db
         .prepare(`SELECT b.todo_id, t.id, t.title FROM todo_blockers b JOIN todos t ON t.id = b.blocker_id
-       WHERE b.todo_id IN (${placeholders}) AND t.status != 'completed'`)
+       WHERE b.todo_id IN (${placeholders}) AND t.${NOT_COMPLETED_TODO_SQL}`)
         .all(...todoIds);
     for (const row of rows) {
         const list = byTodo.get(row.todo_id) ?? [];
@@ -291,11 +288,11 @@ function todoBadgeLevel(status, blocked) {
 function renderTodosSection(index, projectId) {
     const all = db.prepare(OPEN_TODOS_SQL).all(projectId);
     const shown = all.slice(0, TODO_CAP);
-    const blockersByTodo = fetchBlockersFor(shown.filter((t) => t.open_blockers > 0).map((t) => t.id));
-    const blockedCount = all.filter((t) => t.open_blockers > 0).length;
+    const blockersByTodo = fetchBlockersFor(shown.filter((t) => t.blocked).map((t) => t.id));
+    const blockedCount = all.filter((t) => t.blocked).length;
     const rows = shown
         .map((t) => {
-        const blocked = t.open_blockers > 0;
+        const blocked = Boolean(t.blocked);
         const blockers = blocked
             ? (blockersByTodo.get(t.id) ?? []).map((b) => `${mono(`#${b.id}`)} ${prose(b.title)}`).join(", ")
             : "";
@@ -324,7 +321,7 @@ function renderTodosSection(index, projectId) {
             `<p class="filter-none" id="todo-filter-none" hidden>No open todo matches that filter.</p>`
         : "";
     const body = filter +
-        renderCappedList(shown.length, all.length, "open todos", "todos", rows, emptyState("No open todos.", "Every todo in this project is completed or archived. New ones land here."), "todo-list");
+        renderCappedList(shown.length, all.length, "open todos", "todos", rows, emptyState("No open todos.", "No active todos are listed. New open or in-progress todos land here. Backlog todos stay off this list."), "todo-list");
     return section(index, "todos", "Todos", `${all.length} open, ${blockedCount} blocked`, "checklist", String(shown.length), body);
 }
 export const CHART_DAYS = 7;

package/dist/db.js

@@ -576,6 +576,42 @@ ALTER TABLE queen_audit ADD COLUMN problem TEXT NOT NULL DEFAULT '';
 `,
     `
 ALTER TABLE agents ADD COLUMN pane_started_at TEXT;
+`,
+    `
+DROP TRIGGER fence_handoff_held_claim;
+CREATE TRIGGER fence_handoff_held_claim
+BEFORE UPDATE OF fire_count, delivery_method ON wakes
+FOR EACH ROW
+WHEN (NEW.fire_count > OLD.fire_count
+      OR (NEW.delivery_method IS 'pty-after-socket-timeout'
+          AND OLD.delivery_method IS NOT 'pty-after-socket-timeout'
+          AND NEW.typed_at IS NULL))
+  AND EXISTS (
+    SELECT 1 FROM lead_handoffs h
+     WHERE h.lead_agent_id = (SELECT a.id FROM agents a
+                               WHERE a.actor_id = NEW.deliver_actor
+                               ORDER BY (a.status = 'running') DESC,
+                                        a.id DESC
+                               LIMIT 1)
+       AND h.state NOT IN ('completed', 'failed')
+       AND h.request_wake_id IS NOT NEW.id
+       AND (
+            (h.state = 'grace'
+             AND h.hold_released_at IS NULL
+             AND h.grace_started_at IS NOT NULL
+             AND (julianday('now') - julianday(h.grace_started_at)) * 86400 < 900)
+            OR ((h.state IN ('grace', 'started')
+                 OR (h.hold_released_at IS NULL AND (
+                       h.state IN ('respawning', 'ambiguous', 'wind_down')
+                       OR (h.state = 'requested'
+                           AND (h.reason = 'stop' OR h.pass >= 2))
+                       OR (h.state = 'postponed' AND h.reason = 'stop'))))
+                AND h.state <> 'grace'
+                AND (julianday('now') - julianday(h.updated_at)) * 86400 < 3600)
+       ))
+BEGIN
+  SELECT RAISE(IGNORE);
+END;
 `,
 ];
 export function storeSchemaAhead(database) {

package/dist/dispatcher.js

@@ -10,6 +10,9 @@ export const cliPath = () => fileURLToPath(new URL("./cli.js", import.meta.url))
 function shQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
+export function repinCommand(node, cli) {
+    return `${shQuote(node)} ${shQuote(cli)} setup`;
+}
 export function dispatcherScript(node, cli) {
     return [
         "#!/bin/sh",
@@ -17,7 +20,7 @@ export function dispatcherScript(node, cli) {
         "# Written by `hive setup`. It runs hive under one fixed interpreter, so a",
         "# version manager resolving `node` per directory cannot land hive on a Node",
         "# better-sqlite3's addon refuses to load under.",
-        "# Regenerate after every update: npm install && npm run build && hive setup",
+        `# Regenerate after every update: ${repinCommand(node, cli)}`,
         `exec ${shQuote(node)} ${shQuote(cli)} "$@"`,
         "",
     ].join("\n");

package/dist/git.js

@@ -0,0 +1,16 @@
+import { execFileSync } from "node:child_process";
+export function gitOut(cwd, args) {
+    const { GIT_DIR: _gitDir, GIT_COMMON_DIR: _gitCommonDir, GIT_WORK_TREE: _gitWorkTree, ...env } = process.env;
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+            env,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/harnesses.js

@@ -53,7 +53,6 @@ const claudeHarness = {
     supportsRename: true,
     classifiesPaneScreen: true,
     paneClassifier: { choiceCheck: paneChoiceCheck, inputBoxState, inputBoxSnapshot, hasInputBox: paneHasInputBox, trailerView: claudeTrailerView },
-    hasScopes: true,
     needsHome: false,
     // "--" so a message that starts with a dash is never read as a flag.
     initialPromptArgs: (message) => ["--", message],
@@ -82,7 +81,6 @@ export const codexHarness = {
         hasInputBox: codexPaneHasInputBox,
         trailerView: codexTrailerView,
     },
-    hasScopes: false,
     needsHome: true,
     // Auto-submits with no Enter; verified live on v0.149.0.
     initialPromptArgs: (message) => ["--", message],
@@ -106,7 +104,6 @@ const unknownHarness = {
     supportsRename: false,
     classifiesPaneScreen: false,
     paneClassifier: null,
-    hasScopes: false,
     needsHome: false,
     initialPromptArgs: null,
     // An unrecognized command's vocabulary is unknown, so it stops nothing rather than guessing.

package/dist/help.js

@@ -7,10 +7,10 @@ one project-scoped state store: pads, todos, kv, leases.
 Call help(topic="<name>") for details. Topics: ${Object.keys(HELP_TOPICS).join(", ")}.
 
 Scope resolution for project-scoped tools:
-  pass project_id for a one-off override
-  otherwise hive uses the project selected in this session
-  otherwise it auto-detects from the working directory, or auto-selects a
-  single registered project
+  resolution order is project_id override, session selection, worker pin,
+  then working directory; a git worktree or subdirectory resolves to its
+  primary checkout, and an unmatched directory becomes a new project
+  instead of falling back to an unrelated one
 
 Quick start:
   1. whoami — see your actor id and effective project
@@ -46,6 +46,9 @@ QUESTIONS — open questions for the human, recorded in the store
 PROJECTS — scope management
   project_list, project_add, project_select, project_prune
 
+QUEEN AUDIT — confirmed queen writes and refused cross-project guard calls
+  queen_audit_list(project_id?, limit?)
+
 ACTORS — who is writing
   actor_prune`;
 }
@@ -131,7 +134,7 @@ If the human asks to change how work runs here, that is an edit to the
 runbook (fork it first), not a pad write.`,
     agents: `AGENTS — spawn and drive worker sessions in tmux
 
-  agent_spawn(name?, model?, command?, extra_args?, read_only?, cwd?, placement?, layout?) —
+  agent_spawn(name?, model?, command?, extra_args?, harness?, read_only?, cwd?, placement?, layout?, todo_id?) —
     start a worker (default command: claude) in session hive-main.
     placement="split" (default) tiles the worker as a pane in the lead's
     window so the whole crew shares one screen; placement="window" gives it
@@ -169,7 +172,7 @@ runbook (fork it first), not a pad write.`,
     stays agent:N, so older pad writes and todo comments still point here.
     A live claude worker is told to retitle its own session, which arrives as
     a user turn: rename between assignments, not mid-task.
-  agent_park(name|agent_id) — END OF DAY. Kill the pane, mark the row PARKED
+  agent_park(name|agent_id, confirm_self?) — END OF DAY. Kill the pane, mark the row PARKED
     rather than plain closed, record the branch, and hand back a board line
     plus the one call that brings the lane back. Use this instead of
     agent_close whenever the lane is PAUSED rather than finished: "closed"
@@ -179,7 +182,7 @@ runbook (fork it first), not a pad write.`,
     with the same actor_id and its full prior context. It does not send
     the assignment; agent_send it afterwards. Read the pane before
     believing any wake about a worker you just resumed.
-  agent_close(name|agent_id) — kill the worker's pane and mark closed. Capture
+  agent_close(name|agent_id, confirm_self?, row_only?) — kill the worker's pane and mark closed. Capture
     handoffs first; output is not retained. Self-close needs confirm_self.
     On a PARKED row (by agent_id) it releases the park instead, which is how
     you abandon a lane you have decided not to resume. row_only=true marks
@@ -239,8 +242,9 @@ its turn), waiting (needs permission or input). Non-claude commands show
     interval used for firings after this one. Only body can be edited on an
     idle wake (from wake_when_idle); delay_seconds/repeat_every_seconds
     apply to a delay wake (from wake_set) only.
-  wake_cancel(wake_id) — cancel a pending wake-up you own
-  wake_list() — pending wake-ups in this project
+  wake_cancel(wake_id) — cancel a pending wake-up you own, or any pending
+    wake-up in this project when you are a running lead
+  wake_list() — pending wake-ups and recently delivered one-shot wakes
 
 Delivery contract:
   When a wake-up fires, its body is typed into the target session's terminal
@@ -338,7 +342,7 @@ place.`,
   pad_append(pad_id, content, expected_revision?) — add to the end
   pad_edit(pad_id, old_text, new_text, expected_revision?) — replace one
     unique literal occurrence; include enough context to disambiguate
-  pad_list(query?, tags?, include_archived?) — summaries without content;
+  pad_list(query?, tags?, include_archived?, limit?, offset?) — summaries without content;
     query matches names and content and returns a snippet
   pad_archive(pad_id, archived?) — archive frees the name for a new active
     pad; content stays readable by pad_id. archived=false unarchives.
@@ -401,10 +405,12 @@ a phase flag. Use pads for anything longer than a line or two.`,
     to a pending or defaulted question
 
 hive stores the question; it never puts it to the human. Render it in your
-own turn. Answering queues a wake to the asker carrying the question,
-answer and notes, unless the answerer is the asker or the asker cannot be
-reached; the answer is kept either way. Nothing expires or defaults on its
-own: only the asker or the human moves a question out of pending.`,
+own turn. Answering queues a wake to the asker carrying the question, answer
+and notes, or reroutes it to the project's running lead when the asker has
+no running row. It skips wake delivery when you are the asker, no eligible
+target is running, or the target cannot be resolved. The answer stays
+readable either way. Nothing expires or defaults on its own: only the asker
+or the human moves a question out of pending.`,
     leases: `LEASES — advisory expiring claims on shared state
 
   lease_acquire(key, ttl_seconds) — non-blocking; returns the holder if

package/dist/kickoff.js

@@ -1,22 +1,13 @@
-import { execFileSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { cutToUnitBudget } from "./slug.js";
 import { FIRST_MESSAGE_SHA_ENV } from "./firstMessage.js";
+import { gitOut } from "./git.js";
 export const OUTPUT_BUDGET = 10_000;
 const CONTEXT_BUDGET = 6_000;
 const BOARD_BUDGET = 1_800;
 function currentBranch(dir) {
-    try {
-        return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-            cwd: dir,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-    }
-    catch {
-        return null;
-    }
+    return gitOut(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
 }
 export function truncate(text, limit) {
     if (text.length <= limit)
@@ -28,7 +19,7 @@ async function digest(projectPath, profile, warnings) {
     const { findProjectForCwd } = await import("./context.js");
     const { ACTIVE_TIMER_WHERE } = await import("./scheduler.js");
     const { getActivePadByName } = await import("./tools/pads.js");
-    const { OPEN_BLOCKERS_SQL } = await import("./tools/todos.js");
+    const { ACTIVE_TODO_SQL, OPEN_BLOCKERS_SQL } = await import("./todoScope.js");
     migrate();
     const project = findProjectForCwd();
     if (!project || project.path !== projectPath)
@@ -53,7 +44,7 @@ async function digest(projectPath, profile, warnings) {
         .all(project.id);
     const blocked = db
         .prepare(`SELECT COUNT(*) AS n FROM todos t
-         WHERE t.project_id = ? AND t.status IN ('open', 'in_progress') AND t.archived_at IS NULL
+         WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}
            AND EXISTS (${OPEN_BLOCKERS_SQL})`)
         .get(project.id).n;
     if (inFlight.length > 0) {

package/dist/kvValue.js

@@ -0,0 +1,8 @@
+export function decodeKvValue(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/leadHandoffState.js

@@ -30,7 +30,7 @@ export function readActiveHandoff(leadAgentId) {
 export function handoffHoldsAutomation(row) {
     switch (row.state) {
         case "grace":
-            return true;
+            return row.hold_released_at === null && !olderThan(row.grace_started_at, STOP_HOLD_CAP_SECONDS);
         case "started":
             return !olderThan(row.updated_at, HOLD_CEILING_SECONDS);
         case "respawning":

package/dist/portfolio.js

@@ -2,7 +2,7 @@ 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 { ACTIVE_TODO_SQL, OPEN_BLOCKERS_SQL } from "./todoScope.js";
 import { pendingQuestionCount } from "./questions.js";
 import { leadSessionEnded, readLeadTurnState } from "./leadState.js";
 import { liveTargets, ownershipLiveness, rowOwnership } from "./tmux.js";
@@ -63,7 +63,7 @@ function projectRow(project, now, snapshot) {
         .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`)
+        WHERE t.project_id = ? AND ${ACTIVE_TODO_SQL}`)
         .all(project.id);
     const todos = { open: 0, in_progress: 0, blocked: 0, blocked_in_progress: 0, high: 0 };
     const tagged = [];

package/dist/processes.js

@@ -38,6 +38,18 @@ export const STOP_REASONS = {
     leadPaneExited: "lead pane exited",
     previousLead: "left running by a previous lead",
 };
+export function renderStart(result) {
+    switch (result.status) {
+        case "started":
+            return result.message;
+        case "already-running":
+            return `already running${result.location ? ` (${result.location})` : ""}`;
+        case "refused":
+            return result.message ?? "";
+        case "failed":
+            return `failed: ${result.message}`;
+    }
+}
 const STOPPABLE_COLUMNS = "id, project_id, name, tmux_target, tmux_socket, pane_pid, created_at";
 export function runningCommandRows(projectId) {
     return db

package/dist/scheduler.js

@@ -4,6 +4,7 @@ import { existsSync, lstatSync, mkdirSync, realpathSync, renameSync, statSync, u
 import { createHash } from "node:crypto";
 import { dirname, join, sep } from "node:path";
 import { dataDir, db, storeReplaced } from "./db.js";
+import { decodeKvValue } from "./kvValue.js";
 import { maybeBackupHourly } from "./backup.js";
 import { renderDashboardForWrite } from "./dashboard.js";
 import { snapshotProcesses } from "./processes.js";
@@ -183,11 +184,11 @@ function reportDeadProcess(agent, snapshot) {
         // interrupted between the two is not reported as a crash.
         if (stoppingMarkerLive(agent.project_id, agent.id))
             return;
-        const lead = stmt(`SELECT actor_id, tmux_target, tmux_socket, pane_pid FROM agents
+        const lead = stmt(`SELECT actor_id, tmux_target, tmux_socket, pane_pid, command FROM agents
         WHERE project_id = ? AND kind = ? AND status = 'running' ORDER BY id DESC LIMIT 1`).get(agent.project_id, LEAD_KIND);
         // Never mint a notice hive could not deliver: with no live lead pane there is nobody this could
         // ever reach, and the row would sit in wakes forever.
-        if (!lead?.tmux_target || rowOwnership(lead, snapshot) !== "live")
+        if (!lead?.tmux_target || !screenClassifiable(lead.command) || rowOwnership(lead, snapshot) !== "live")
             return;
         insertNotice({ project_id: agent.project_id, owner: lead.actor_id }, lead.actor_id, lead.tmux_target, deadProcessBody(agent.name), null);
     }
@@ -410,19 +411,22 @@ function renderQueenPage(queenId) {
 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);
+    bestEffortRun("INSERT OR IGNORE INTO kv (project_id, key, value, updated_at) VALUES (?, ?, ?, '1970-01-01 00:00:00')", queenId, QUEEN_PAGE_CLAIM_KEY, JSON.stringify(""));
     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;
+    if (!row)
+        return null;
+    const value = decodeKvValue(row.value);
+    return typeof value === "string" ? value : row.value;
 }
 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);
+     ON CONFLICT(project_id, key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')`, queenId, QUEEN_PAGE_MARK_KEY, JSON.stringify(page.hash));
 }
 export function generateQueenDashboardNow() {
     try {
@@ -494,6 +498,24 @@ function driveOwnLeadHandoff() {
     catch {
     }
 }
+function isolated(label, task) {
+    const report = (err) => {
+        try {
+            console.error(`[scheduler] ${label} failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        catch {
+        }
+    };
+    try {
+        const result = task();
+        if (result !== null && typeof result === "object" && "then" in result) {
+            return Promise.resolve(result).then(() => { }, report);
+        }
+    }
+    catch (err) {
+        report(err);
+    }
+}
 export async function tick(snapshot) {
     if (ticking)
         return;
@@ -506,14 +528,15 @@ export async function tick(snapshot) {
         }
         if (snapshot === undefined)
             snapshot = liveTargets();
-        janitor(snapshot);
-        if (snapshot)
-            reportRunningBuildChange(snapshot);
-        driveOwnLeadHandoff();
-        checkConfirmations();
-        pruneStateLog();
-        maybeBackupHourly(db, dataDir);
-        maybeGenerateDashboards();
+        const tickSnapshot = snapshot;
+        isolated("janitor", () => janitor(tickSnapshot));
+        if (tickSnapshot)
+            isolated("running-build check", () => reportRunningBuildChange(tickSnapshot));
+        isolated("lead handoff", driveOwnLeadHandoff);
+        isolated("wake confirmations", checkConfirmations);
+        isolated("state-log pruning", pruneStateLog);
+        isolated("hourly backup", () => maybeBackupHourly(db, dataDir));
+        isolated("dashboard generation", maybeGenerateDashboards);
         const now = stmt("SELECT datetime('now') AS now").get().now;
         const candidates = stmt(`SELECT wakes.*, ${DELIVER_ROW_COLUMNS}
          FROM wakes ${DELIVER_SOCKET_JOIN}
@@ -524,18 +547,20 @@ export async function tick(snapshot) {
        )`).all();
         const choices = new Map();
         for (const timer of candidates) {
-            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);
+            await isolated(`timer ${timer.id}`, async () => {
+                if (timer.kind === "delay") {
+                    await fireDelay(timer, tickSnapshot, choices);
+                    return;
+                }
+                const leadWatch = leadSubscription(timer.id);
+                if (leadWatch !== null)
+                    await maybeFireLeadWatch(timer, leadWatch, tickSnapshot, now, choices);
+                else
+                    await maybeFireIdle(timer, tickSnapshot, now, choices);
+            });
         }
-        await retryUnconfirmedSocketWakes(snapshot, choices);
-        await retryQuietLeadMessages(snapshot);
+        await isolated("unconfirmed socket wake retry", () => retryUnconfirmedSocketWakes(tickSnapshot, choices));
+        await isolated("quiet lead message retry", () => retryQuietLeadMessages(tickSnapshot));
     }
     catch {
     }
@@ -972,6 +997,8 @@ function alreadyToldAbout(timerId, agentId, blockedSince) {
 const CONDITION_IDLE = "idle";
 const CONDITION_GONE = "gone";
 const NOTICE_RETRY_AFTER = "-60 seconds";
+const spentUntypedNotice = (alias) => `${alias}.fired_at IS NOT NULL AND COALESCE(${alias}.typed_at, ${alias}.socket_attempt_at) IS NULL ` +
+    `AND ${alias}.cancelled_at IS NULL AND ${alias}.fired_at < datetime('now', '${NOTICE_RETRY_AFTER}')`;
 const NOTICE_MAX_AGE = "-1 hours";
 const ROSTER_STILL_GOING = 8;
 const FINISHED_SHOWN_CAP = ROSTER_STILL_GOING;
@@ -979,8 +1006,7 @@ const STANDING_EXPIRED_NOTE = "this standing watch has expired and nothing is wa
 const unreported = (condition, episode) => `NOT EXISTS (
     SELECT 1 FROM wake_idle_notices n LEFT JOIN wakes nt ON nt.id = n.notice_wake_id
      WHERE n.wake_id = ? AND n.agent_id = a.id AND n.condition = '${condition}' AND n.episode = ${episode}
-       AND NOT (nt.fired_at IS NOT NULL AND COALESCE(nt.typed_at, nt.socket_attempt_at) IS NULL AND nt.cancelled_at IS NULL
-                AND nt.fired_at < datetime('now', '${NOTICE_RETRY_AFTER}')))`;
+       AND NOT (${spentUntypedNotice("nt")}))`;
 const CREW_COLUMNS = `a.id, a.name, a.actor_id, a.tmux_target, a.tmux_socket, a.pane_pid, a.agent_state,
    a.state_changed_at, a.status, a.command, a.kind, a.resumed_at, a.closed_at,
    a.cwd, a.session_id, a.transcript_path`;
@@ -1218,12 +1244,11 @@ function standingNoticeBody(timer, finished, totalFinished, carriedTotal, span)
     return lines.join("\n");
 }
 function rearmSpentEpisode(timerId, agentId, condition, episode) {
-    stmt(`DELETE FROM wake_idle_notices
+    return stmt(`DELETE FROM wake_idle_notices
       WHERE wake_id = ? AND agent_id = ? AND condition = ? AND episode = ?
         AND notice_wake_id IS NOT NULL
         AND EXISTS (SELECT 1 FROM wakes t WHERE t.id = wake_idle_notices.notice_wake_id
-                      AND t.fired_at IS NOT NULL AND COALESCE(t.typed_at, t.socket_attempt_at) IS NULL AND t.cancelled_at IS NULL
-                      AND t.fired_at < datetime('now', '${NOTICE_RETRY_AFTER}'))`).run(timerId, agentId, condition, episode);
+                      AND ${spentUntypedNotice("t")})`).run(timerId, agentId, condition, episode).changes > 0;
 }
 function claimEpisode(timerId, agentId, condition, episode) {
     return (stmt(`INSERT OR IGNORE INTO wake_idle_notices (wake_id, agent_id, condition, episode)
@@ -1366,11 +1391,15 @@ const claimStallBatch = db.transaction((timer, tell, candidates, observedAt) =>
         return false;
     const won = [];
     for (const c of candidates) {
-        if (c.row.agent_state === "waiting" && !claimBlockNotice(timer.id, c.row.id, c.row.episode))
+        const rearmed = rearmSpentEpisode(timer.id, c.row.id, CONDITION_STALL, c.row.episode);
+        if (!claimEpisode(timer.id, c.row.id, CONDITION_STALL, c.row.episode))
             continue;
-        rearmSpentEpisode(timer.id, c.row.id, CONDITION_STALL, c.row.episode);
-        if (claimEpisode(timer.id, c.row.id, CONDITION_STALL, c.row.episode))
-            won.push(c);
+        if (c.row.agent_state === "waiting" && !rearmed && !claimBlockNotice(timer.id, c.row.id, c.row.episode)) {
+            stmt(`DELETE FROM wake_idle_notices
+            WHERE wake_id = ? AND agent_id = ? AND condition = ? AND episode = ? AND notice_wake_id IS NULL`).run(timer.id, c.row.id, CONDITION_STALL, c.row.episode);
+            continue;
+        }
+        won.push(c);
     }
     if (won.length === 0)
         return false;
@@ -2164,10 +2193,21 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner, fall
             return;
         if (firing !== null && !pasted)
             dropRepeatingFiring(timer, firing, err);
-        if (!(err instanceof PaneOwnershipLost))
-            throw err;
-        if (firing === null || pasted)
-            recordLostAfterClaim(timer, pasted, err.message, firing);
+        if (err instanceof PaneOwnershipLost) {
+            if (firing === null || pasted) {
+                recordLostAfterClaim(timer, pasted, err instanceof Error ? err.message : String(err), firing);
+            }
+            return;
+        }
+        if (pasted) {
+            const repairableNotice = stmt(`SELECT 1 FROM wake_idle_notices n JOIN wakes w ON w.id = n.notice_wake_id
+          WHERE n.notice_wake_id = ? AND w.fired_at IS NOT NULL
+            AND COALESCE(w.typed_at, w.socket_attempt_at) IS NULL AND w.cancelled_at IS NULL
+          LIMIT 1`).get(timer.id);
+            if (pasted && repairableNotice === undefined) {
+                recordLostAfterClaim(timer, pasted, err instanceof Error ? err.message : String(err), firing);
+            }
+        }
         return;
     }
     finally {

package/dist/spawn.js

@@ -1,7 +1,7 @@
-import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { preservedRolloutPath, reapCodexHome } from "./codexHome.js";
 import { getProject } from "./context.js";
+import { gitOut } from "./git.js";
 import { dataDir, db } from "./db.js";
 import { loadProjectYml } from "./projectYml.js";
 import { applyLayout, claimInitialWindow, createWindow, DEFAULT_LAYOUT, ensureSession, crossServerRefusal, findProcessesWindow, findProjectWindow, isPaneTarget, paneProcessExited, paneWindow, PROCESSES_LAYOUT, processesPaneTitle, processesWindowName, retainOnExitArgs, rowLive, sessionName, setPaneTitle, setRemainOnExit, makeProcessesWindow, tmux, tmuxSocketPath, untrustedTmuxServer, waitForPaneEstablished, windowLayout, windowOwner, windowTitle, rowOwnership, } from "./tmux.js";
@@ -347,34 +347,19 @@ export function renameAgent(agent, newName, projectName) {
     }
 }
 export function branchAt(cwd) {
-    const git = (args) => {
-        try {
-            return execFileSync("git", args, {
-                cwd,
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-                timeout: 2000,
-            }).trim();
-        }
-        catch {
-            return null;
-        }
-    };
-    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branch = gitOut(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
     if (branch === null)
         return "";
     if (branch !== "HEAD")
         return branch;
-    return git(["rev-parse", "--short", "HEAD"]) ?? "";
+    return gitOut(cwd, ["rev-parse", "--short", "HEAD"]) ?? "";
 }
 export function parkAgentRow(agentId, expected, branch) {
     const park = "UPDATE agents SET status = 'closed', closed_at = datetime('now'), parked_at = datetime('now'), " +
         "parked_branch = ? WHERE id = ? AND status = 'running' AND tmux_target = ?";
-    const row = typeof expected === "string"
-        ? db.prepare(`${park} RETURNING parked_at`).get(branch, agentId, expected)
-        : db
-            .prepare(`${park} AND tmux_socket = ? AND pane_pid = ? RETURNING parked_at`)
-            .get(branch, agentId, expected.tmux_target, expected.tmux_socket, expected.pane_pid);
+    const row = db
+        .prepare(`${park} AND tmux_socket = ? AND pane_pid = ? RETURNING parked_at`)
+        .get(branch, agentId, expected.tmux_target, expected.tmux_socket, expected.pane_pid);
     return row?.parked_at;
 }
 export const paneIdentity = (row) => ({
@@ -455,13 +440,9 @@ export function closeAgentRow(agentId, expected) {
         ? db
             .prepare("UPDATE agents SET status = 'closed', closed_at = datetime('now') WHERE id = ? AND status = 'running'")
             .run(agentId)
-        : typeof expected === "string"
-            ? db
-                .prepare("UPDATE agents SET status = 'closed', closed_at = datetime('now') WHERE id = ? AND status = 'running' AND tmux_target = ?")
-                .run(agentId, expected)
-            : db
-                .prepare("UPDATE agents SET status = 'closed', closed_at = datetime('now') WHERE id = ? AND status = 'running' " +
-                "AND tmux_target = ? AND tmux_socket = ? AND pane_pid = ?")
-                .run(agentId, expected.tmux_target, expected.tmux_socket, expected.pane_pid);
+        : db
+            .prepare("UPDATE agents SET status = 'closed', closed_at = datetime('now') WHERE id = ? AND status = 'running' " +
+            "AND tmux_target = ? AND tmux_socket = ? AND pane_pid = ?")
+            .run(agentId, expected.tmux_target, expected.tmux_socket, expected.pane_pid);
     return info.changes > 0;
 }

package/dist/todoScope.js

@@ -0,0 +1,5 @@
+export const ACTIVE_TODO_SQL = "t.status IN ('open', 'in_progress') AND t.archived_at IS NULL";
+export const NOT_COMPLETED_TODO_SQL = "status != 'completed'";
+export const OPEN_BLOCKERS_FROM_WHERE = `FROM todo_blockers b JOIN todos bt ON bt.id = b.blocker_id
+   WHERE b.todo_id = t.id AND bt.${NOT_COMPLETED_TODO_SQL}`;
+export const OPEN_BLOCKERS_SQL = `SELECT 1 ${OPEN_BLOCKERS_FROM_WHERE}`;

package/dist/tools/agents.js

@@ -695,19 +695,15 @@ export function registerAgents(server) {
                                     note: "The pane never became ready. The brief is loaded regardless; check agent_output before sending the worker its assignment - typing into it now risks losing the text silently.",
                                 }),
                 }
-                : harness.classifiesPaneScreen
-                    ? {
-                        instructions: workerBrief(briefFor(actorId)),
-                    }
-                    : {
-                        brief_path: writeAgentBrief(agentId, workerBrief(briefFor(actorId))),
-                        note: `This worker runs ${JSON.stringify(commandHead(baseCommand))}, which hive cannot brief and ` +
-                            "cannot type into: the guards that make typing safe read claude's chrome, so agent_send's " +
-                            "text path refuses this pane. There are no instructions to prepend, because there is no " +
-                            "supported way to send them. The brief is written to brief_path - open that pane " +
-                            "(tmux attach) and paste it in yourself, or drive the worker with agent_send(keys: [...]). " +
-                            "Wakes aimed at this worker are refused for the same reason.",
-                    }),
+                : {
+                    brief_path: writeAgentBrief(agentId, workerBrief(briefFor(actorId))),
+                    note: `This worker runs ${JSON.stringify(commandHead(baseCommand))}, which hive cannot brief and ` +
+                        "cannot type into: the guards that make typing safe read claude's chrome, so agent_send's " +
+                        "text path refuses this pane. There are no instructions to prepend, because there is no " +
+                        "supported way to send them. The brief is written to brief_path - open that pane " +
+                        "(tmux attach) and paste it in yourself, or drive the worker with agent_send(keys: [...]). " +
+                        "Wakes aimed at this worker are refused for the same reason.",
+                }),
         };
         if (omittedTodoWarning) {
             const existingNote = typeof receipt.note === "string" ? receipt.note : "";
@@ -996,6 +992,7 @@ export function registerAgents(server) {
             const classifier = renameHarness.paneClassifier;
             const { awaitingChoice, tail } = classifier.choiceCheck(agent.tmux_target);
             const box = awaitingChoice === false ? classifier.inputBoxState(agent.tmux_target) : null;
+            const inCopyMode = paneInCopyMode(agent.tmux_target);
             if (awaitingChoice === true) {
                 heldNote =
                     "Not retitled: the pane is waiting on a choice, so typing /rename would answer it instead of setting the title. Clear the prompt first (agent_send with keys), then retry.";
@@ -1017,6 +1014,11 @@ export function registerAgents(server) {
                     `Not retitled: the pane's input box holds unsubmitted text, so /rename would be pasted onto the end of it and submitted as prose rather than run as a command. The row IS renamed - it is "${newName}" now - and only the pane's own title was left alone. Clear the line with agent_send(keys: ["C-a", "C-k"]) once you can attribute the text, then call agent_rename(name: "${newName}", new_name: "${newName}") to retitle the pane.`;
                 heldTail = tail;
             }
+            else if (inCopyMode === true) {
+                heldNote =
+                    `Not retitled: the pane is in tmux copy mode, so /rename would not reach its prompt. The row IS renamed - it is "${newName}" now - and only the pane's own title was left alone. Leave copy mode (press q or Escape there), then call agent_rename(name: "${newName}", new_name: "${newName}") to retitle the pane.`;
+                heldTail = tail;
+            }
             else {
                 let pasted = false;
                 try {
@@ -1191,6 +1193,7 @@ export function registerAgents(server) {
         const agent = resolveQueenLeadTarget("agent_send", project.id, args.agent_id ?? args.name, () => findAgent(project.id, args));
         requireLive(agent);
         const target = agent.tmux_target;
+        const identity = paneIdentity(agent);
         const auditIdentity = captureQueenWriteIdentity(project.id);
         let outgoing = args.text ?? "";
         const tag = senderTag(project.id, currentActor());
@@ -1241,10 +1244,9 @@ export function registerAgents(server) {
                 }
                 if (args.wait_ms == null)
                     return quiet;
-                await sleep(Math.min(Math.max(args.wait_ms, 250), 10000));
+                await sleep(args.wait_ms);
                 try {
-                    if (observeOwnership(agent) !== "live")
-                        throw new Error("not live");
+                    requireStillOwned(agent.id, identity, "agent_send");
                     return { ...quiet, tail: capturePane(target, 15) };
                 }
                 catch {
@@ -1342,7 +1344,6 @@ export function registerAgents(server) {
                 outgoing = tag + args.text;
             let pasted = false;
             let buffered = false;
-            const identity = paneIdentity(agent);
             try {
                 await sendText(target, outgoing, submitting, () => {
                     pasted = true;
@@ -1376,9 +1377,10 @@ export function registerAgents(server) {
             throw new Error("Pass text or keys.");
         }
         if (args.wait_ms != null) {
-            await sleep(Math.min(Math.max(args.wait_ms, 250), 10000));
+            await sleep(args.wait_ms);
             let tailField;
             try {
+                requireStillOwned(agent.id, identity, "agent_send");
                 tailField = { tail: capturePane(target, 15) };
             }
             catch {

package/dist/tools/kv.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { db } from "../db.js";
 import { currentActor, effectiveProjectId } from "../context.js";
 import { run } from "../result.js";
+import { decodeKvValue } from "../kvValue.js";
 import { idParam, projectIdParam } from "./params.js";
 function purgeExpired(projectId) {
     db.prepare("DELETE FROM kv WHERE project_id = ? AND expires_at IS NOT NULL AND expires_at < datetime('now')").run(projectId);
@@ -56,7 +57,7 @@ export function registerKv(server) {
             project_id: projectId,
             key: row.key,
             found: true,
-            value: JSON.parse(row.value),
+            value: decodeKvValue(row.value),
             updated_by: row.updated_by,
             updated_at: row.updated_at,
             expires_at: row.expires_at,
@@ -76,9 +77,9 @@ export function registerKv(server) {
         purgeExpired(projectId);
         let sql = "SELECT * FROM kv WHERE project_id = ?";
         const params = [projectId];
-        if (args.prefix) {
-            sql += " AND key LIKE ?";
-            params.push(`${args.prefix}%`);
+        if (args.prefix !== undefined) {
+            sql += " AND substr(key, 1, length(?)) = ?";
+            params.push(args.prefix, args.prefix);
         }
         sql += " ORDER BY key";
         const rows = db.prepare(sql).all(...params);
@@ -86,7 +87,7 @@ export function registerKv(server) {
             project_id: projectId,
             entries: rows.map((r) => ({
                 key: r.key,
-                value: JSON.parse(r.value),
+                value: decodeKvValue(r.value),
                 updated_by: r.updated_by,
                 updated_at: r.updated_at,
                 expires_at: r.expires_at,

package/dist/tools/todos.js

@@ -6,6 +6,7 @@ import { matchesAnyTag, parseTags, run } from "../result.js";
 import { findUnsafeControlChar } from "../tmux.js";
 import { SLUG_MAX_LEN, fallbackSlug } from "../slug.js";
 import { idParam, limitParam, offsetParam, projectIdParam } from "./params.js";
+import { NOT_COMPLETED_TODO_SQL, OPEN_BLOCKERS_FROM_WHERE, OPEN_BLOCKERS_SQL } from "../todoScope.js";
 const priorityParam = z.enum(["high", "medium", "low"]);
 const slugParam = z
     .string()
@@ -19,11 +20,8 @@ const slugParam = z
 export { SLUG_MAX_LEN, fallbackSlug };
 export const TODO_STATUSES = ["open", "in_progress", "backlog", "completed"];
 const statusParam = z.enum(TODO_STATUSES);
-const OPEN_BLOCKERS_FROM_WHERE = `FROM todo_blockers b JOIN todos bt ON bt.id = b.blocker_id
-   WHERE b.todo_id = t.id AND bt.status != 'completed'`;
-export const OPEN_BLOCKERS_SQL = `SELECT 1 ${OPEN_BLOCKERS_FROM_WHERE}`;
 const LIVE_DEPENDENTS_SQL = `SELECT t.id AS todo_id FROM todo_blockers b JOIN todos t ON t.id = b.todo_id
-   WHERE b.blocker_id = ? AND t.status != 'completed' AND t.archived_at IS NULL`;
+   WHERE b.blocker_id = ? AND t.${NOT_COMPLETED_TODO_SQL} AND t.archived_at IS NULL`;
 export const COMMENT_COUNT_SQL = `(SELECT COUNT(*) FROM todo_comments c WHERE c.todo_id = t.id)`;
 const SUMMARY_SQL = `
   SELECT t.*,
@@ -191,10 +189,7 @@ const completeTodo = db.transaction((projectId, todoId, completed) => {
     if (completed) {
         newlyUnblocked = db
             .prepare(`${LIVE_DEPENDENTS_SQL}
-             AND NOT EXISTS (
-               SELECT 1 FROM todo_blockers b2 JOIN todos bt ON bt.id = b2.blocker_id
-               WHERE b2.todo_id = t.id AND bt.status != 'completed'
-             )`)
+             AND NOT EXISTS (${OPEN_BLOCKERS_SQL})`)
             .all(todo.id).map((r) => r.todo_id);
     }
     return { todo_id: todo.id, completed, newly_unblocked: newlyUnblocked };

package/dist/version.js

@@ -1,7 +1,7 @@
-import { execFileSync } from "node:child_process";
 import { readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { gitOut } from "./git.js";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const checkoutRoot = join(moduleDir, "..");
 function readBuildInfo() {
@@ -60,22 +60,9 @@ function packageVersion() {
     }
 }
 function currentGit() {
-    try {
-        const sha = execFileSync("git", ["rev-parse", "--short", "HEAD"], {
-            cwd: checkoutRoot,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        const status = execFileSync("git", ["status", "--porcelain"], {
-            cwd: checkoutRoot,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        return { sha, dirty: status.trim().length > 0 };
-    }
-    catch {
-        return null;
-    }
+    const sha = gitOut(checkoutRoot, ["rev-parse", "--short", "HEAD"]);
+    const status = gitOut(checkoutRoot, ["status", "--porcelain"]);
+    return sha === null || status === null ? null : { sha, dirty: status.length > 0 };
 }
 const describe = (sha, dirty) => `${sha}${dirty ? "-dirty" : ""}`;
 export function versionInfo() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "description": "Run a crew of Claude Code and Codex workers from one lead session: visible tmux panes, exact state from hooks, one local SQLite store.",
   "type": "module",
   "bin": {