@cmgmyr/hive 1.1.0 → 1.2.1

package/README.md

@@ -67,3 +67,7 @@ hive is a personal daily-driver tool, released low-key. It is single-user by des
 | [Tools](docs/tools.md) | The 45 MCP tools: what each does and when to use it |
 | [tmux settings](docs/tmux.md) | Attach modes, pane options, and what to put in `~/.tmux.conf` |
 | [Development](docs/development.md) | Building and testing hive itself |
+
+## Updating
+
+Run `hive upgrade` for a global npm install, or `hive upgrade --check` to preview the commands without changing your install. In a git checkout, the default prints the recipe; `hive upgrade --run` executes it. Upgrade reports Claude Code and Codex registration repairs without editing their configs. Restart every session with hive loaded after the upgrade. See [Updating and recovery](docs/install.md#updating).

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.1.0","sha":"38f535a","dirty":false}
+{"version":"1.2.1","sha":"1d14c85","dirty":false,"build_id":"6d50625e-ceaf-412d-8dcf-6b7a922fceaa"}

package/dist/cli.js

@@ -11,9 +11,11 @@ import { versionInfo } from "./version.js";
 import { claudeConfigDir } from "./claudeDir.js";
 import { ATTACH_MODES, AUTO_ATTACH_MODES, attachMode, isAttachMode, isAutoAttach, resolvedAttachMode, resolvedAutoAttach, setAttachMode, setAutoAttach, } from "./config.js";
 import { cliPath, dispatcherDir, dispatcherPath, dispatcherScript, durabilityLines, firstHiveOnPath, linkedWorktreePin, pathAdvice, readDispatcher, } from "./dispatcher.js";
-import { codexConfigPath, codexHiveRegistrations, hiveRegistrations, registrationOffer, registrationProblem, } from "./mcpConfig.js";
+import { codexConfigPath, codexHiveRegistrations, codexRegistrationProblem, hiveRegistrations, registrationOffer, registrationProblem, } from "./mcpConfig.js";
 import { DEFAULT_DATA_DIR } from "./dataDir.js";
 import { dataDir, db, migrate, storeSchemaAhead } from "./db.js";
+import { cacheIsStale, queryUpdate, readCachedUpdate, refreshUpdate, shouldAutoRefresh, updateLine } from "./updateCheck.js";
+import { checkoutUpgradeSteps, detectInstallShape, globalUpgradeSteps } from "./upgrade.js";
 import { isLowHeadroom, orphanLoginShellDetails, ptyHeadroom } from "./ptys.js";
 import { addProject, agentProjectPin, currentActor, effectiveProjectId, findProjectForCwd, getProjectByPath, gitPrimaryRoot, getProject, listProjects, registeredAncestor, takeRegistrationNotice, } from "./context.js";
 import { ensureHooksFile } from "./hooks.js";
@@ -57,6 +59,8 @@ Usage:
   hive show <process> [path]  move a running process's pane beside the lead
   hive hide <process> [path]  move it back into the <project>/processes window
   hive status                overview of agents, todos, and wake-ups everywhere
+  hive upgrade [--check]    upgrade a global npm install; preview with --check
+  hive upgrade --run        run the printed pull/install/build/setup checkout recipe
   hive setup [--dir <dir>]   write a \`hive\` that runs the interpreter this build
                              was compiled for; re-run after every update
   hive setup --attach <mode> auto|raw|control: whether tmux attaches carry -CC
@@ -559,15 +563,20 @@ placement: split                # placement for workers and visible processes: s
 
 # lead: claude --model opus     # custom command for the lead window (default: claude)
 
+# agents: [claude, codex]       # crew harness pool; the first entry is the default
+
 # lead_branches: [main, master] # branches where a session gets hive's kickoff
 
 # context_checkpoint_percent: null # unset means off; integer 1-100 to enable
 
 # lead_turn_budget: {warn: 300, stop: 600} # optional lead statusline thresholds
 
+# dashboard: true               # write .hive/dashboard.html (default: false)
+
 # review_tags: [from-review]    # todo tags \`hive doctor\` counts as review findings and
                                 # reports as triaged (has a comment, completed, or archived)
-                                # or untriaged. Absent means doctor tracks none.
+                                # or untriaged. A tag also matches its own suffixed rounds.
+                                # Absent means it tracks none.
 
 # vars:                         # substituted into the profile runbook
 #   repo: owner/name            # {{repo}}
@@ -1454,6 +1463,74 @@ const verboseInfo = (_check, label, ...lines) => {
         report("info", label, lines);
 };
 const isReviewFindingTag = (bases, tag) => bases.some((base) => tag === base || tag.startsWith(`${base}-`));
+function cmdUpgrade(argv) {
+    const parsed = parseArgs(argv, { flags: ["--check", "--run"] });
+    rejectUnknownFlags("upgrade", parsed, "--check, --run");
+    if (parsed.positional.length || (parsed.flags.has("--check") && parsed.flags.has("--run"))) {
+        console.error("hive upgrade: use --check or --run, without positional arguments.");
+        process.exitCode = 1;
+        return;
+    }
+    const shape = detectInstallShape();
+    if (shape.kind === "unknown") {
+        console.error(`Cannot upgrade this install: ${shape.reason}`);
+        console.error(`CLI: ${shape.cli}\nPackage root: ${shape.packageRoot}\n.git: ${shape.gitState}\nnpm root -g: ${shape.npmRoot ?? "unavailable"}`);
+        console.error("Put the npm for this package's global root first on PATH, or use a git checkout.");
+        process.exitCode = 1;
+        return;
+    }
+    if (shape.kind === "global" && parsed.flags.has("--run")) {
+        console.error("hive upgrade: --run is only for checkouts; global installs upgrade by default.");
+        process.exitCode = 1;
+        return;
+    }
+    const steps = shape.kind === "checkout" ? checkoutUpgradeSteps(shape.packageRoot) : globalUpgradeSteps(shape);
+    const render = (step) => [step.command, ...step.args]
+        .map((arg) => /^[a-zA-Z0-9_@./=-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", "'\\''")}'`).join(" ");
+    const restart = "Restart every Claude Code or Codex session that has hive loaded; existing sessions keep running old in-memory code.";
+    if (shape.kind === "global") {
+        const update = queryUpdate();
+        console.log(updateLine(update));
+        if (update.status === "unknown") {
+            console.error("not upgrading: could not read the latest version");
+            process.exitCode = 1;
+            return;
+        }
+        if (update.status === "current")
+            return;
+    }
+    if (parsed.flags.has("--check") || (shape.kind === "checkout" && !parsed.flags.has("--run"))) {
+        console.log(shape.kind === "checkout" ? `Checkout: ${shape.packageRoot}\nRun in that directory, or use hive upgrade --run:` : "Would run:");
+        for (const step of steps)
+            console.log(`  ${render(step)}`);
+        console.log(restart);
+        return;
+    }
+    for (const [index, step] of steps.entries()) {
+        console.log(`\n${step.label}: ${render(step)}`);
+        const result = spawnSync(step.command, step.args, { cwd: step.cwd, stdio: "inherit" });
+        if (result.status === 0 && !result.error && !result.signal)
+            continue;
+        console.error(`${step.label} failed: ${result.error?.message ?? (result.signal ? `signal ${result.signal}` : `exit ${result.status}`)}`);
+        if (shape.kind === "global") {
+            console.error(index === 0
+                ? "npm may have left the global package partially changed. Retry the install, then repair setup:"
+                : "The package is new, but the dispatcher was not confirmed re-pinned. Repair setup:");
+            for (const remaining of steps.slice(index))
+                console.error(`  ${render(remaining)}`);
+            console.error("  hive doctor --strict");
+        }
+        else {
+            console.error(`Stopped at ${render(step)}. Remaining recipe not run:`);
+            for (const remaining of steps.slice(index + 1))
+                console.error(`  ${render(remaining)}`);
+        }
+        console.error(`After repair: ${restart}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`\nUpgrade complete. ${restart}`);
+}
 function cmdSetup(argv) {
     const parsed = parseArgs(argv, { flags: ["--force"], valued: ["--dir", "--attach", "--auto-attach"] });
     rejectUnknownFlags("setup", parsed, "--dir, --attach, --auto-attach, --force");
@@ -1531,8 +1608,8 @@ function cmdSetup(argv) {
     console.log("");
     for (const line of durabilityLines(node))
         console.log(line);
-    console.log("\nA rebuild does not re-pin anything on its own. After every update:");
-    console.log("  npm install && npm run build && hive setup");
+    console.log("\nFor future updates, run hive upgrade. It re-pins after installing;");
+    console.log("checkouts print the recipe and run it only with --run.");
     console.log(`\nPATH: ${pathAdvice(dir, file).join("\n")}`);
     reportSetupRegistrations(node);
 }
@@ -1549,7 +1626,14 @@ function reportSetupRegistrations(pinned) {
             for (const line of lines.slice(1))
                 console.log(`  ${line}`);
         }
-        return;
+    }
+    for (const r of codexHiveRegistrations()) {
+        const lines = codexRegistrationProblem(r, pinned);
+        if (!lines)
+            continue;
+        console.log(`\n  mcp registration (codex): ${lines[0]}`);
+        for (const line of lines.slice(1))
+            console.log(`  ${line}`);
     }
     const offer = registrationOffer(pinned, found);
     if (offer) {
@@ -1655,6 +1739,9 @@ function reportMcpRegistrations(project) {
     }
     for (const r of codexRegistrations) {
         info("mcp registration (codex)", [r.command, ...r.args].join(" "));
+        const problem = codexRegistrationProblem(r, process.execPath);
+        if (problem)
+            gatingWarn("mcp registration (codex)", ...problem);
     }
 }
 const PTY_OVERRIDE_VARS = ["HIVE_PTY_HEADROOM_JSON", "HIVE_PTY_PS_ROWS_JSON", "HIVE_ORPHAN_SCRATCH_JSON"];
@@ -1963,6 +2050,13 @@ function cmdDoctor(argv) {
         const { line, drift } = versionInfo();
         return drift ? [line, drift].join("\n        ") : line;
     });
+    let cachedUpdate = readCachedUpdate();
+    if (cacheIsStale(cachedUpdate) && shouldAutoRefresh())
+        cachedUpdate = refreshUpdate();
+    if (cachedUpdate?.status === "newer" && cachedUpdate.checkedAt) {
+        const hours = Math.max(0, Math.floor((Date.now() - Date.parse(cachedUpdate.checkedAt)) / (60 * 60 * 1000)));
+        warn("update", `${updateLine(cachedUpdate)} (checked ${hours}h ago)`);
+    }
     check("node", () => describeInterpreter());
     check("better-sqlite3", () => {
         const status = checkAbi();
@@ -2837,10 +2931,21 @@ if (command === "--version" || command === "-v") {
     console.log(line);
     if (drift)
         console.log(`! ${drift}`);
+    if (rest.includes("--check")) {
+        if (process.env.HIVE_NO_UPDATE_CHECK === "1")
+            console.log("update check disabled (HIVE_NO_UPDATE_CHECK)");
+        else
+            console.log(updateLine(refreshUpdate()));
+    }
+    else {
+        const cached = readCachedUpdate();
+        if (cached?.status === "newer" && !cacheIsStale(cached))
+            console.log(`! ${updateLine(cached)}`);
+    }
     process.exit(0);
 }
 const COMMANDS = [
-    "lead", "init", "attach", "start", "stop", "show", "hide", "status", "setup", "doctor",
+    "lead", "init", "attach", "start", "stop", "show", "hide", "status", "setup", "upgrade", "doctor",
     LEAD_PANE_EXITED_VERB,
     "pads", "pad", "todos", "todo", "backups", "restore", "runbook", "posture", "profile", "kickoff", "statusline",
 ];
@@ -2857,7 +2962,8 @@ if (!COMMANDS.includes(command)) {
         usage();
     }
 }
-migrate();
+if (command !== "upgrade")
+    migrate();
 try {
     switch (command) {
         case "lead":
@@ -2890,6 +2996,9 @@ try {
         case "setup":
             cmdSetup(rest);
             break;
+        case "upgrade":
+            cmdUpgrade(rest);
+            break;
         case "doctor":
             cmdDoctor(rest);
             break;

package/dist/index.js

@@ -10,7 +10,7 @@ import { registerKv } from "./tools/kv.js";
 import { registerLeases } from "./tools/leases.js";
 import { registerWakes } from "./tools/wakes.js";
 import { registerPrompts } from "./prompts.js";
-import { startScheduler } from "./scheduler.js";
+import { schedulerIntervalMs, startScheduler } from "./scheduler.js";
 import { enforceStrictInput } from "./strictInput.js";
 const server = enforceStrictInput(new McpServer({ name: "hive", version: "0.1.0" }, {
     instructions: `Hive gives Claude Code sessions shared, persistent state for coordinating work on a project: pads for plans and findings, todos for tracked work with blockers, kv for small shared values, leases for claiming shared work areas, agents for spawning and directing other sessions, and wake-ups for scheduled or idle-triggered check-ins. Search for these tools when a task needs to persist past this conversation, hand off to or watch another session, or track multi-step work with dependencies.
@@ -30,5 +30,5 @@ registerKv(server);
 registerLeases(server);
 registerWakes(server);
 registerPrompts(server);
-startScheduler();
+startScheduler(schedulerIntervalMs());
 await server.connect(new StdioServerTransport());

package/dist/mcpConfig.js

@@ -1,14 +1,27 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseToml } from "smol-toml";
-const serverPath = () => fileURLToPath(new URL("./index.js", import.meta.url));
+export const serverPath = () => fileURLToPath(new URL("./index.js", import.meta.url));
+function serverProblem(args, expected) {
+    const server = args[0];
+    if (!server)
+        return "has no server path.";
+    if (!existsSync(server))
+        return `points at a missing server: ${server}`;
+    try {
+        if (realpathSync(server) === realpathSync(expected))
+            return null;
+    }
+    catch { }
+    return `points at a different server: ${server} (expected ${expected})`;
+}
 function addCommand(scope, name, pinned, args) {
     return `  claude mcp add --scope ${scope} ${name} -- ${[pinned, ...args].map((a) => `"${a}"`).join(" ")}`;
 }
-export function registrationProblem(r, pinned) {
-    const reRegister = [addCommand(r.scope, r.name, pinned, r.args)];
+export function registrationProblem(r, pinned, expectedServer = serverPath()) {
+    const reRegister = [addCommand(r.scope, r.name, pinned, [expectedServer])];
     if (!r.command.includes("/")) {
         return [
             `runs "${r.command}", which a Node version manager re-resolves per`,
@@ -25,7 +38,23 @@ export function registrationProblem(r, pinned) {
             ...reRegister,
         ];
     }
-    return null;
+    const problem = serverProblem(r.args, expectedServer);
+    return problem ? [problem, `Re-register in ${r.source}:`, ...reRegister] : null;
+}
+export function codexRegistrationProblem(r, pinned, expectedServer = serverPath()) {
+    const problem = !r.command.includes("/")
+        ? `runs "${r.command}", which a Node version manager re-resolves per directory.`
+        : r.command !== pinned
+            ? `pins a different interpreter than this CLI runs (${pinned}).`
+            : serverProblem(r.args, expectedServer);
+    if (!problem)
+        return null;
+    return [
+        problem,
+        `Re-register in ${r.source}:`,
+        `  codex mcp remove ${r.name}`,
+        `  codex mcp add ${r.name} -- "${pinned}" "${expectedServer}"`,
+    ];
 }
 function readJson(file) {
     try {

package/dist/result.js

@@ -1,3 +1,4 @@
+import { runningBuildChange, runningBuildNotice } from "./version.js";
 export function errorMessage(e) {
     return e instanceof Error ? e.message : String(e);
 }
@@ -14,10 +15,32 @@ export function registrationNoticeText(notice) {
         `it if it owns nothing yet, run the session from the intended directory, or call ` +
         `project_select.`);
 }
+const reportedBuilds = new Set();
+export async function appendRunningBuildNotice(result, session) {
+    try {
+        const change = runningBuildChange();
+        if (!change || reportedBuilds.has(change.disk.build_id))
+            return result;
+        const actor = process.env.HIVE_AGENT_ID;
+        if (actor) {
+            const { db } = await import("./db.js");
+            const row = db.prepare("SELECT kind FROM agents WHERE actor_id = ?").get(actor);
+            if (row?.kind === "agent")
+                return result;
+        }
+        if (reportedBuilds.has(change.disk.build_id))
+            return result;
+        result.content.push({ type: "text", text: runningBuildNotice(change, session) });
+        reportedBuilds.add(change.disk.build_id);
+    }
+    catch {
+    }
+    return result;
+}
 export async function run(fn) {
     const { storeReplaced } = await import("./db.js");
     if (storeReplaced()) {
-        return { content: [{ type: "text", text: STORE_REPLACED_MESSAGE }], isError: true };
+        return appendRunningBuildNotice({ content: [{ type: "text", text: STORE_REPLACED_MESSAGE }], isError: true });
     }
     const { takeRegistrationNotice } = await import("./context.js");
     let result;
@@ -31,7 +54,7 @@ export async function run(fn) {
     if (notice) {
         result.content.push({ type: "text", text: registrationNoticeText(notice) });
     }
-    return result;
+    return appendRunningBuildNotice(result);
 }
 export function parseTags(text) {
     try {

package/dist/scheduler.js

@@ -1,3 +1,4 @@
+import { runningBuildChange, runningBuildNotice } from "./version.js";
 import { existsSync, mkdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, sep } from "node:path";
 import { dataDir, db, storeReplaced } from "./db.js";
@@ -42,7 +43,7 @@ function bestEffortRun(sql, ...params) {
 }
 let ticking = false;
 let schedulerInterval;
-export function startScheduler(intervalMs = 3000) {
+export function startScheduler(intervalMs = DEFAULT_SCHEDULER_INTERVAL_MS) {
     schedulerInterval = setInterval(() => {
         void tick();
     }, intervalMs).unref();
@@ -161,6 +162,25 @@ function reportDeadProcess(agent, snapshot) {
     catch {
     }
 }
+const reportedBuilds = new Set();
+export function reportRunningBuildChange(snapshot) {
+    try {
+        const change = runningBuildChange();
+        const actor = process.env.HIVE_AGENT_ID;
+        if (!change || !actor || reportedBuilds.has(change.disk.build_id))
+            return;
+        const lead = stmt(`SELECT project_id, actor_id, tmux_target, tmux_socket, pane_pid, command FROM agents
+       WHERE actor_id = ? AND kind = ? AND status = 'running'`).get(actor, LEAD_KIND);
+        if (!lead?.tmux_target || !screenClassifiable(lead.command) ||
+            rowAlive(lead.tmux_socket, lead.tmux_target, snapshot) !== true ||
+            paneReissued(lead.pane_pid, rowAliveProbe(lead.tmux_socket, lead.tmux_target, snapshot)))
+            return;
+        insertNotice({ project_id: lead.project_id, owner: lead.actor_id }, lead.actor_id, lead.tmux_target, runningBuildNotice(change), null);
+        reportedBuilds.add(change.disk.build_id);
+    }
+    catch {
+    }
+}
 const deadProcessBody = (name) => `[hive] process "${name}" exited on its own; its pane is gone. Restart it with: hive start "${name}"`;
 export function janitor(snapshot = liveTargets()) {
     const reapedCodexHomes = reapClosedCodexHomes();
@@ -359,6 +379,8 @@ export async function tick(snapshot) {
         if (snapshot === undefined)
             snapshot = liveTargets();
         janitor(snapshot);
+        if (snapshot)
+            reportRunningBuildChange(snapshot);
         checkConfirmations();
         pruneStateLog();
         maybeBackupHourly(db, dataDir);
@@ -1620,3 +1642,13 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt) {
     if (!strandedTextWouldHold)
         recordTyped();
 }
+export const DEFAULT_SCHEDULER_INTERVAL_MS = 3000;
+const MIN_SCHEDULER_INTERVAL_MS = 100;
+// Node clamps a setInterval delay above this to 1ms.
+const MAX_SCHEDULER_INTERVAL_MS = 2_147_483_647;
+export function schedulerIntervalMs(raw = process.env.HIVE_SCHEDULER_INTERVAL_MS) {
+    const parsed = Number(raw);
+    return raw && Number.isInteger(parsed) && parsed >= MIN_SCHEDULER_INTERVAL_MS && parsed <= MAX_SCHEDULER_INTERVAL_MS
+        ? parsed
+        : DEFAULT_SCHEDULER_INTERVAL_MS;
+}

package/dist/updateCheck.js

@@ -0,0 +1,111 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { storeDir } from "./dataDir.js";
+import { versionInfo } from "./version.js";
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_FILE = "update-check.json";
+const VERSION_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+function currentVersion() {
+    return versionInfo().line.match(/^hive\s+(\S+)/)?.[1] ?? "0.0.0";
+}
+function compareVersions(current, latest) {
+    const currentMatch = VERSION_RE.exec(current);
+    const latestMatch = VERSION_RE.exec(latest);
+    if (!currentMatch || !latestMatch)
+        return "unknown";
+    for (let i = 1; i <= 3; i += 1) {
+        const difference = Number(latestMatch[i]) - Number(currentMatch[i]);
+        if (difference > 0)
+            return "newer";
+        if (difference < 0)
+            return "current";
+    }
+    return "current";
+}
+function fromCache(record) {
+    const current = currentVersion();
+    if (record.error !== null) {
+        return { current, latest: null, status: "unknown", reason: record.error, checkedAt: record.checked_at };
+    }
+    const latest = typeof record.latest === "string" ? record.latest : null;
+    const status = latest === null ? "unknown" : compareVersions(current, latest);
+    return {
+        current,
+        latest,
+        status,
+        reason: status === "unknown" ? "unparseable version" : null,
+        checkedAt: record.checked_at,
+    };
+}
+function cachePath() {
+    return join(storeDir(), CACHE_FILE);
+}
+export function readCachedUpdate() {
+    try {
+        const raw = JSON.parse(readFileSync(cachePath(), "utf8"));
+        if (typeof raw.checked_at !== "string" || (typeof raw.latest !== "string" && raw.latest !== null) || (typeof raw.error !== "string" && raw.error !== null)) {
+            return null;
+        }
+        return fromCache({ checked_at: raw.checked_at, latest: raw.latest, error: raw.error });
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(result) {
+    const dir = storeDir();
+    mkdirSync(dir, { recursive: true });
+    const path = cachePath();
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, JSON.stringify({ checked_at: result.checkedAt, latest: result.latest, error: result.reason }));
+    renameSync(temporary, path);
+}
+export function queryUpdate() {
+    const current = currentVersion();
+    const checkedAt = new Date().toISOString();
+    let latest = null;
+    let reason = null;
+    if (process.env.HIVE_NO_UPDATE_CHECK === "1") {
+        reason = "disabled (HIVE_NO_UPDATE_CHECK)";
+    }
+    else {
+        try {
+            latest = execFileSync("npm", ["view", "@cmgmyr/hive", "version"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 5000,
+            }).trim();
+            if (!VERSION_RE.test(latest) || !VERSION_RE.test(current))
+                reason = "unparseable version";
+        }
+        catch (error) {
+            const code = error.code;
+            reason = code === "ENOENT" ? "npm not found" : code === "ETIMEDOUT" ? "timed out" : "offline or npm failed";
+        }
+    }
+    const status = reason === null && latest !== null ? compareVersions(current, latest) : "unknown";
+    return { current, latest, status, reason, checkedAt };
+}
+export function refreshUpdate() {
+    const result = queryUpdate();
+    writeCache(result);
+    return result;
+}
+export function cacheIsStale(update, now = Date.now()) {
+    if (!update?.checkedAt)
+        return true;
+    const checked = Date.parse(update.checkedAt);
+    return !Number.isFinite(checked) || now - checked >= CACHE_TTL_MS;
+}
+export function updateLine(update) {
+    if (update.status === "newer" && update.latest) {
+        return `update available: hive ${update.latest} (you have ${update.current}); run: hive upgrade`;
+    }
+    if (update.status === "current")
+        return `up to date: hive ${update.current} is the latest on npm`;
+    return `update check: unknown (${update.reason ?? "offline or npm failed"})`;
+}
+export function shouldAutoRefresh() {
+    return process.stdout.isTTY === true && !process.env.CI && process.env.HIVE_NO_UPDATE_CHECK !== "1";
+}

package/dist/upgrade.js

@@ -0,0 +1,49 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { cliPath } from "./dispatcher.js";
+export function detectInstallShape(cli = cliPath(), npmCommand = "npm") {
+    const packageRoot = dirname(dirname(cli));
+    let gitState = "absent";
+    try {
+        const git = statSync(join(packageRoot, ".git"));
+        if (git.isDirectory() || git.isFile())
+            return { kind: "checkout", packageRoot };
+        gitState = "neither file nor directory";
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            gitState = String(error);
+    }
+    let npmRoot = null;
+    let reason;
+    try {
+        npmRoot = execFileSync(npmCommand, ["root", "-g"], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000,
+        }).trim();
+        if (!isAbsolute(npmRoot))
+            throw new Error("npm root -g did not return an absolute path");
+        if (realpathSync(packageRoot) === realpathSync(join(npmRoot, "@cmgmyr/hive"))) {
+            return { kind: "global", packageRoot, npmRoot, npmCommand };
+        }
+        reason = "npm root -g does not own the running package";
+    }
+    catch (error) {
+        reason = `could not confirm npm root ownership: ${String(error)}`;
+    }
+    return { kind: "unknown", packageRoot, cli, gitState, npmRoot, reason };
+}
+export function checkoutUpgradeSteps(packageRoot, node = process.execPath) {
+    return [
+        { label: "pull", command: "git", args: ["pull", "--ff-only"], cwd: packageRoot },
+        { label: "install", command: "npm", args: ["install"], cwd: packageRoot },
+        { label: "build", command: "npm", args: ["run", "build"], cwd: packageRoot },
+        { label: "setup", command: node, args: [join(packageRoot, "dist/cli.js"), "setup"], cwd: packageRoot },
+    ];
+}
+export function globalUpgradeSteps(shape, node = process.execPath) {
+    return [
+        { label: "install", command: shape.npmCommand, args: ["install", "-g", "@cmgmyr/hive@latest"] },
+        { label: "setup", command: node, args: [join(shape.npmRoot, "@cmgmyr/hive/dist/cli.js"), "setup"] },
+    ];
+}

package/dist/version.js

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -13,6 +13,43 @@ function readBuildInfo() {
         return null;
     }
 }
+function readRunningBuild() {
+    const info = readBuildInfo();
+    return info && typeof info.build_id === "string" && info.build_id.trim() !== "" &&
+        (info.sha === null || typeof info.sha === "string") && typeof info.dirty === "boolean"
+        ? info : null;
+}
+const loadedBuild = readRunningBuild();
+let diskSignature;
+let diskBuild = null;
+export function runningBuildChange() {
+    try {
+        if (!loadedBuild)
+            return null;
+        const stat = statSync(join(moduleDir, "build-info.json"));
+        const signature = `${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+        if (signature !== diskSignature) {
+            diskBuild = readRunningBuild();
+            diskSignature = signature;
+        }
+        return diskBuild && diskBuild.build_id !== loadedBuild.build_id
+            ? { loaded: loadedBuild, disk: diskBuild } : null;
+    }
+    catch {
+        diskSignature = undefined;
+        diskBuild = null;
+        return null;
+    }
+}
+export function runningBuildNotice(change, session) {
+    const subject = session ? `session ${JSON.stringify(session)}'s` : "this session's";
+    const detail = (info) => info.sha === null ? "no git sha" : describe(info.sha, info.dirty);
+    const sameDescription = change.loaded.version === change.disk.version && detail(change.loaded) === detail(change.disk);
+    const label = (info) => `hive ${info.version} (${detail(info)}${sameDescription ? `, build ${info.build_id.slice(0, 8)}` : ""})`;
+    return `hive: ${subject} hive server loaded ${label(change.loaded)}; ` +
+        `the build on disk changed to ${label(change.disk)}. ` +
+        "Restart this session, or reconnect hive in /mcp, to pick it up.";
+}
 function packageVersion() {
     try {
         const raw = JSON.parse(readFileSync(join(checkoutRoot, "package.json"), "utf8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Shared memory and coordination for Claude Code sessions: one lead, many tmux workers, one project-scoped store.",
   "type": "module",
   "bin": {