@cmgmyr/hive 1.2.1 → 1.3.0

package/dist/projectYml.js

@@ -1,11 +1,29 @@
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { resolve, sep } from "node:path";
 import { parse } from "yaml";
 import { harnessNames } from "./harnesses.js";
 import { isValidProfileName } from "./profiles.js";
 import { errorMessage } from "./result.js";
 import { isWindowLayout, WINDOW_LAYOUTS } from "./tmux.js";
+import { globalConfigPath, isEmptyYamlDocument, readGlobalConfig, resolveAttachSetting, } from "./globalConfig.js";
+export const BUILT_IN_PROJECT_YML = Object.freeze({
+    lead: null,
+    placement: null,
+    layout: null,
+    profile: null,
+    agents: null,
+    lead_branches: null,
+    context_checkpoint_percent: null,
+    lead_turn_budget: null,
+    dashboard: false,
+    vars: Object.freeze({}),
+    processes: Object.freeze({}),
+});
+export const PROJECT_YML_KEYS = Object.freeze(Object.keys(BUILT_IN_PROJECT_YML));
+export function createBuiltInProjectYml() {
+    return structuredClone(BUILT_IN_PROJECT_YML);
+}
 export const DEFAULT_LEAD_BRANCHES = ["main", "master"];
 export const NO_PROFILE = "none";
 export function activeProfile(config) {
@@ -37,224 +55,251 @@ export function mergedProjectVars(config) {
         delete safe[key];
     return { ...safe, ...agentVars(config) };
 }
-export function loadProjectYml(projectPath) {
-    const warnings = [];
-    const file = join(projectPath, "hive.yml");
-    if (!existsSync(file))
-        return { config: null, warnings };
-    let raw;
+function isMapping(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function parseFile(path, warnings) {
+    let text;
     try {
-        raw = parse(readFileSync(file, "utf8"));
-    }
-    catch (e) {
-        warnings.push(`hive.yml is not valid YAML: ${errorMessage(e)}`);
-        return { config: null, warnings };
+        text = readFileSync(path, "utf8");
     }
-    if (raw == null || typeof raw !== "object") {
-        warnings.push("hive.yml must be a YAML mapping.");
-        return { config: null, warnings };
-    }
-    const root = raw;
-    let context_checkpoint_percent = null;
-    if (root.context_checkpoint_percent != null) {
-        const value = root.context_checkpoint_percent;
-        if (typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100) {
-            context_checkpoint_percent = value;
-        }
-        else {
-            warnings.push("context_checkpoint_percent must be an integer from 1 through 100; ignoring it.");
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            warnings.push(`${path}: could not read hive.yml: ${errorMessage(error)}`);
         }
+        return null;
     }
-    let lead_turn_budget = null;
-    if (root.lead_turn_budget != null) {
-        const value = root.lead_turn_budget;
-        const budget = typeof value === "object" && value !== null && !Array.isArray(value)
-            ? value
-            : null;
-        const warn = budget?.warn;
-        const stop = budget?.stop;
-        if (typeof warn === "number" && Number.isInteger(warn) && warn > 0 &&
-            typeof stop === "number" && Number.isInteger(stop) && stop > warn) {
-            lead_turn_budget = { warn, stop };
-        }
-        else {
-            warnings.push("lead_turn_budget must contain positive integer warn and stop values, with stop greater than warn; ignoring it.");
+    try {
+        const raw = parse(text);
+        if (raw == null && isEmptyYamlDocument(text))
+            return null;
+        if (!isMapping(raw)) {
+            warnings.push(`${path}: hive.yml must be a YAML mapping.`);
+            return null;
         }
+        return raw;
     }
-    const lead = typeof root.lead === "string" && root.lead.trim() !== "" ? root.lead.trim() : null;
-    let placement = null;
-    if (root.placement != null) {
-        if (root.placement === "split" || root.placement === "window") {
-            placement = root.placement;
-        }
-        else {
-            warnings.push(`placement must be "split" or "window"; ignoring "${String(root.placement)}".`);
-        }
+    catch (error) {
+        warnings.push(`${path}: hive.yml is not valid YAML: ${errorMessage(error)}`);
+        return null;
     }
-    let layout = null;
-    if (root.layout != null) {
-        if (isWindowLayout(root.layout)) {
-            layout = root.layout;
+}
+function parseProcesses(value, path, warnings) {
+    if (!isMapping(value)) {
+        warnings.push(`${path}: hive.yml \`processes\` must be a mapping of name to command.`);
+        return null;
+    }
+    const processes = {};
+    for (const [name, item] of Object.entries(value)) {
+        if (typeof item === "string" && item.trim() !== "") {
+            processes[name] = { command: item.trim(), dir: null, auto_start: true, visible: true, env: {} };
+            continue;
         }
-        else {
-            warnings.push(`layout must be one of ${WINDOW_LAYOUTS.join(", ")}; ignoring "${String(root.layout)}".`);
+        if (!isMapping(item)) {
+            warnings.push(`${path}: Process "${name}" needs a command string; skipped.`);
+            continue;
         }
-    }
-    let profile = null;
-    if (root.profile != null) {
-        const value = String(root.profile).trim();
-        if (value === "") {
-            warnings.push("profile is empty; ignoring it.");
+        if (typeof item.command !== "string" || item.command.trim() === "") {
+            warnings.push(`${path}: Process "${name}" has no command; skipped.`);
+            continue;
         }
-        else if (value !== NO_PROFILE && !isValidProfileName(value)) {
-            warnings.push(`profile "${value}" is not a valid profile name (letters, digits, dot, dash, underscore); ignoring it.`);
+        const dirValue = item.dir ?? item.working_dir;
+        let visible = true;
+        if (item.visible != null) {
+            if (typeof item.visible === "boolean")
+                visible = item.visible;
+            else
+                warnings.push(`${path}: Process "${name}": visible must be true or false; ignoring "${String(item.visible)}".`);
         }
-        else {
-            profile = value;
+        const env = {};
+        if (isMapping(item.env)) {
+            for (const [key, envValue] of Object.entries(item.env))
+                env[key] = String(envValue);
         }
+        processes[name] = {
+            command: item.command.trim(),
+            dir: typeof dirValue === "string" && dirValue.trim() !== "" ? dirValue.trim() : null,
+            auto_start: item.auto_start !== false,
+            visible,
+            env,
+        };
     }
-    let agents = null;
-    if (root.agents != null) {
-        if (!Array.isArray(root.agents)) {
-            warnings.push("agents must be a list of harness names; ignoring it.");
+    return processes;
+}
+function applyLayer(root, path, source, config, sources, warnings) {
+    const has = (key) => Object.hasOwn(root, key);
+    const warn = (message) => warnings.push(`${path}: ${message}`);
+    const assignNullable = (key, valid, message) => {
+        if (!has(key))
+            return;
+        const value = root[key];
+        if (value == null) {
+            config[key] = null;
+            sources[key] = source;
         }
         else {
-            const known = harnessNames();
-            const valid = [];
-            for (const entry of root.agents) {
-                const value = typeof entry === "string" ? entry.trim() : "";
-                if (value === "") {
-                    warnings.push("agents entry must be a non-empty harness name; skipped.");
-                }
-                else if (!known.includes(value)) {
-                    warnings.push(`agents: "${value}" is not a known harness (${known.join(", ")}); ignoring it.`);
-                }
-                else {
-                    valid.push(value);
-                }
+            const normalized = valid(value);
+            if (normalized === undefined)
+                warn(message(value));
+            else {
+                config[key] = normalized;
+                sources[key] = source;
             }
-            agents = valid.length > 0 ? valid : null;
         }
-    }
-    const review_tags = [];
-    if (root.review_tags != null) {
-        if (!Array.isArray(root.review_tags)) {
-            warnings.push("review_tags must be a list of todo tags; ignoring it.");
+    };
+    assignNullable("lead", (value) => typeof value === "string" && value.trim() ? value.trim() : undefined, (value) => `lead must be a non-empty command string; ignoring "${String(value)}".`);
+    assignNullable("placement", (value) => value === "split" || value === "window" ? value : undefined, (value) => `placement must be "split" or "window"; ignoring "${String(value)}".`);
+    assignNullable("layout", (value) => isWindowLayout(value) ? value : undefined, (value) => `layout must be one of ${WINDOW_LAYOUTS.join(", ")}; ignoring "${String(value)}".`);
+    assignNullable("profile", (value) => {
+        const name = String(value).trim();
+        return name !== "" && (name === NO_PROFILE || isValidProfileName(name)) ? name : undefined;
+    }, (value) => typeof value === "string" && value.trim() === ""
+        ? "profile is empty; ignoring it."
+        : `profile "${String(value).trim()}" is not a valid profile name (letters, digits, dot, dash, underscore); ignoring it.`);
+    assignNullable("context_checkpoint_percent", (value) => typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100 ? value : undefined, () => "context_checkpoint_percent must be an integer from 1 through 100; ignoring it.");
+    if (has("lead_turn_budget")) {
+        const value = root.lead_turn_budget;
+        if (value == null) {
+            config.lead_turn_budget = null;
+            sources.lead_turn_budget = source;
+        }
+        else if (isMapping(value) && typeof value.warn === "number" && Number.isInteger(value.warn) && value.warn > 0 &&
+            typeof value.stop === "number" && Number.isInteger(value.stop) && value.stop > value.warn) {
+            config.lead_turn_budget = { warn: value.warn, stop: value.stop };
+            sources.lead_turn_budget = source;
         }
         else {
-            for (const entry of root.review_tags) {
-                const value = typeof entry === "string" ? entry.trim() : "";
-                if (value === "") {
-                    warnings.push("review_tags entry must be a non-empty tag; skipped.");
-                }
-                else if (!review_tags.includes(value)) {
-                    review_tags.push(value);
-                }
-            }
+            warn("lead_turn_budget must contain positive integer warn and stop values, with stop greater than warn; ignoring it.");
         }
     }
-    let lead_branches = null;
-    if (root.lead_branches != null) {
-        const raw = Array.isArray(root.lead_branches) ? root.lead_branches : null;
-        const branches = raw
-            ?.filter((b) => typeof b === "string" && b.trim() !== "")
-            .map((b) => b.trim());
-        if (branches && branches.length === raw.length) {
-            lead_branches = branches;
+    if (has("dashboard")) {
+        const value = root.dashboard;
+        if (value == null) {
+            config.dashboard = false;
+            sources.dashboard = source;
         }
-        else {
-            warnings.push("lead_branches must be a list of branch names; ignoring it.");
+        else if (typeof value === "boolean") {
+            config.dashboard = value;
+            sources.dashboard = source;
         }
+        else
+            warn(`dashboard must be true or false; ignoring "${String(value)}".`);
     }
-    let dashboard = false;
-    if (root.dashboard != null) {
-        if (typeof root.dashboard === "boolean") {
-            dashboard = root.dashboard;
+    if (has("agents")) {
+        const value = root.agents;
+        if (value == null) {
+            config.agents = null;
+            sources.agents = source;
         }
-        else {
-            warnings.push(`dashboard must be true or false; ignoring "${String(root.dashboard)}".`);
+        else if (Array.isArray(value)) {
+            const known = harnessNames();
+            const valid = [];
+            for (const entry of value) {
+                const name = typeof entry === "string" ? entry.trim() : "";
+                if (!name)
+                    warn("agents entry must be a non-empty harness name; skipped.");
+                else if (!known.includes(name))
+                    warn(`agents: "${name}" is not a known harness (${known.join(", ")}); ignoring it.`);
+                else
+                    valid.push(name);
+            }
+            config.agents = valid.length ? valid : null;
+            sources.agents = source;
         }
+        else
+            warn("agents must be a list of harness names; ignoring it.");
     }
-    const vars = {};
-    if (root.vars != null) {
-        if (typeof root.vars !== "object" || Array.isArray(root.vars)) {
-            warnings.push("vars must be a mapping of name to value; ignoring it.");
+    if (has("lead_branches")) {
+        const value = root.lead_branches;
+        if (value == null) {
+            config.lead_branches = null;
+            sources.lead_branches = source;
         }
-        else {
-            for (const [key, value] of Object.entries(root.vars)) {
-                if (value == null || typeof value === "object") {
-                    warnings.push(`var "${key}" must be a scalar; skipped.`);
-                    continue;
-                }
-                vars[key] = String(value);
-            }
+        else if (Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim() !== "")) {
+            config.lead_branches = value.map((item) => item.trim());
+            sources.lead_branches = source;
         }
+        else
+            warn("lead_branches must be a list of branch names; ignoring it.");
     }
-    const processes = {};
-    const rawProcesses = root.processes;
-    if (rawProcesses != null) {
-        if (typeof rawProcesses !== "object") {
-            warnings.push("hive.yml `processes` must be a mapping of name to command.");
+    if (has("vars")) {
+        const value = root.vars;
+        if (value == null) {
+            for (const key of Object.keys(config.vars))
+                sources[`vars.${key}`] = source;
+            config.vars = {};
+            sources.vars = source;
         }
-        else {
-            for (const [name, value] of Object.entries(rawProcesses)) {
-                if (typeof value === "string" && value.trim() !== "") {
-                    processes[name] = { command: value.trim(), dir: null, auto_start: true, visible: true, env: {} };
-                    continue;
-                }
-                if (value == null || typeof value !== "object") {
-                    warnings.push(`Process "${name}" needs a command string; skipped.`);
-                    continue;
-                }
-                const p = value;
-                if (typeof p.command !== "string" || p.command.trim() === "") {
-                    warnings.push(`Process "${name}" has no command; skipped.`);
-                    continue;
+        else if (isMapping(value)) {
+            for (const [key, item] of Object.entries(value)) {
+                if (item == null) {
+                    delete config.vars[key];
+                    sources[`vars.${key}`] = source;
+                    sources.vars = source;
                 }
-                const dirValue = p.dir ?? p.working_dir;
-                let visible = true;
-                if (p.visible != null) {
-                    if (typeof p.visible === "boolean") {
-                        visible = p.visible;
-                    }
-                    else {
-                        warnings.push(`Process "${name}": visible must be true or false; ignoring "${String(p.visible)}".`);
-                    }
+                else if (typeof item === "object") {
+                    warn(`var "${key}" must be a scalar; skipped.`);
                 }
-                const env = {};
-                if (p.env != null && typeof p.env === "object") {
-                    for (const [k, v] of Object.entries(p.env)) {
-                        env[k] = String(v);
-                    }
+                else {
+                    config.vars[key] = String(item);
+                    sources[`vars.${key}`] = source;
+                    sources.vars = source;
                 }
-                processes[name] = {
-                    command: p.command.trim(),
-                    dir: typeof dirValue === "string" && dirValue.trim() !== "" ? dirValue.trim() : null,
-                    auto_start: p.auto_start !== false,
-                    visible,
-                    env,
-                };
             }
         }
+        else
+            warn("vars must be a mapping of name to value; ignoring it.");
+    }
+    if (has("processes")) {
+        if (source === "global")
+            warn("global hive.yml cannot define `processes`; only project commands can be trusted.");
+        else if (root.processes != null) {
+            const processes = parseProcesses(root.processes, path, warnings);
+            if (processes != null) {
+                config.processes = processes;
+                sources.processes = source;
+            }
+        }
+    }
+    for (const key of ["attach", "autoAttach"]) {
+        if (source === "project" && has(key))
+            warn(`${key} is global-only; ignoring it in project hive.yml.`);
     }
+    if (has("review_tags"))
+        warn("review_tags is no longer used by hive; remove it from hive.yml.");
+}
+export function resolveHiveConfig(projectPath) {
+    const global = readGlobalConfig();
+    const warnings = [...global.warnings];
+    const config = createBuiltInProjectYml();
+    const sources = Object.fromEntries(PROJECT_YML_KEYS.map((key) => [key, "built-in"]));
+    if (global.root)
+        applyLayer(global.root, globalConfigPath(), "global", config, sources, warnings);
+    let projectValid = false;
+    if (projectPath != null) {
+        const file = resolve(projectPath, "hive.yml");
+        const project = parseFile(file, warnings);
+        if (project) {
+            projectValid = true;
+            applyLayer(project, file, "project", config, sources, warnings);
+        }
+    }
+    const attachResult = resolveAttachSetting("attach", global.root, global.legacy, warnings);
+    const autoAttachResult = resolveAttachSetting("autoAttach", global.root, global.legacy, warnings);
     return {
-        config: {
-            lead,
-            placement,
-            layout,
-            profile,
-            agents,
-            review_tags,
-            lead_branches,
-            context_checkpoint_percent,
-            lead_turn_budget,
-            dashboard,
-            vars,
-            processes,
-        },
+        config: global.root || projectValid ? config : null,
         warnings,
+        sources,
+        attach: attachResult,
+        autoAttach: autoAttachResult,
     };
 }
+export function loadProjectYml(projectPath) {
+    return resolveHiveConfig(projectPath);
+}
 export function configHash(name, command, dir, env) {
     return createHash("sha256")
         .update(JSON.stringify([name, command, dir, env]))

package/dist/result.js

@@ -16,6 +16,23 @@ export function registrationNoticeText(notice) {
         `project_select.`);
 }
 const reportedBuilds = new Set();
+const pendingNotices = new WeakMap();
+function addNotice(result, text, build) {
+    result.content.push({ type: "text", text });
+    const pending = pendingNotices.get(result) ?? { texts: [] };
+    pending.texts.push(text);
+    if (build)
+        pending.build = build;
+    pendingNotices.set(result, pending);
+}
+export function noticeFor(result) {
+    return pendingNotices.get(result)?.texts.join("\n");
+}
+export function releaseNotice(result) {
+    const build = pendingNotices.get(result)?.build;
+    if (build)
+        reportedBuilds.delete(build);
+}
 export async function appendRunningBuildNotice(result, session) {
     try {
         const change = runningBuildChange();
@@ -30,8 +47,8 @@ export async function appendRunningBuildNotice(result, session) {
         }
         if (reportedBuilds.has(change.disk.build_id))
             return result;
-        result.content.push({ type: "text", text: runningBuildNotice(change, session) });
         reportedBuilds.add(change.disk.build_id);
+        addNotice(result, runningBuildNotice(change, session), change.disk.build_id);
     }
     catch {
     }
@@ -52,7 +69,7 @@ export async function run(fn) {
     }
     const notice = takeRegistrationNotice();
     if (notice) {
-        result.content.push({ type: "text", text: registrationNoticeText(notice) });
+        addNotice(result, registrationNoticeText(notice));
     }
     return appendRunningBuildNotice(result);
 }

package/dist/scheduler.js

@@ -1460,6 +1460,12 @@ function watchedStates(timer, snapshot) {
         };
     });
 }
+function idleConditionMet(timer, snapshot) {
+    const states = watchedStates(timer, snapshot);
+    return timer.kind === "idle_any"
+        ? states.some((s) => s.gone || (s.idle && s.since != null && s.since >= timer.created_at))
+        : states.length > 0 && states.every((s) => s.idle);
+}
 async function maybeFireIdle(timer, snapshot, now, choices) {
     const timedOut = timer.max_wait_at != null && timer.max_wait_at <= now;
     if (isStandingWatch(timer)) {
@@ -1476,24 +1482,24 @@ async function maybeFireIdle(timer, snapshot, now, choices) {
         return;
     }
     let ready = false;
+    let idleMet = false;
     if (timedOut) {
         ready = true;
+        if (snapshot !== null)
+            idleMet = idleConditionMet(timer, snapshot);
     }
     else {
         if (snapshot === null)
             return;
-        const states = watchedStates(timer, snapshot);
-        ready =
-            timer.kind === "idle_any"
-                ? states.some((s) => s.gone || (s.idle && s.since != null && s.since >= timer.created_at))
-                : states.length > 0 && states.every((s) => s.idle);
+        idleMet = idleConditionMet(timer, snapshot);
+        ready = idleMet;
         if (!ready)
             noteBlockedWatched(timer, snapshot, choices);
     }
     if (ready) {
         const decision = deliverable(timer, snapshot, choices);
         if (decision.ok && claimOneShot(timer)) {
-            await deliver(timer, timedOut ? "max wait reached" : "", choices, decision.typedSeen, decision.firstHeldAt);
+            await deliver(timer, timedOut && !idleMet ? "max wait reached" : "", choices, decision.typedSeen, decision.firstHeldAt);
         }
     }
 }

package/dist/spawn.js

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

package/dist/strictInput.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { noticeFor, releaseNotice } from "./result.js";
 function isBuiltSchema(value) {
     return typeof value === "object" && value !== null && ("_zod" in value || "_def" in value);
 }
@@ -14,11 +15,15 @@ function strictSchemaFor(toolName, inputSchema) {
 }
 // The SDK requires structuredContent whenever outputSchema is declared but never populates it itself,
 // so this stays scoped to declaring tools rather than attached blanket in src/result.ts's ok().
+// Claude Code shows the model structuredContent and drops content for these tools, so a notice
+// appended to content reaches it only as structuredContent.hive_notice.
 function withStructuredContent(name, cb) {
     return async (...args) => {
         const result = (await cb(...args));
-        if (result.isError || result.structuredContent)
+        if (result.isError)
             return result;
+        if (result.structuredContent)
+            return withNotice(result);
         const first = result.content[0];
         const text = first?.type === "text" ? first.text : undefined;
         let parsed;
@@ -30,8 +35,9 @@ function withStructuredContent(name, cb) {
         }
         if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
             result.structuredContent = parsed;
-            return result;
+            return withNotice(result);
         }
+        releaseNotice(result);
         return {
             content: [
                 {
@@ -45,8 +51,23 @@ function withStructuredContent(name, cb) {
         };
     };
 }
+function withNotice(result) {
+    const notice = noticeFor(result);
+    if (notice && result.structuredContent)
+        result.structuredContent = { ...result.structuredContent, hive_notice: notice };
+    return result;
+}
+function withNoticeField(outputSchema) {
+    return outputSchema === undefined || isBuiltSchema(outputSchema)
+        ? outputSchema
+        : { ...outputSchema, hive_notice: z.string().optional() };
+}
 export function enforceStrictInput(server) {
     const register = server.registerTool.bind(server);
-    server.registerTool = ((name, config, cb) => register(name, { ...config, inputSchema: strictSchemaFor(name, config.inputSchema) }, (config.outputSchema ? withStructuredContent(name, cb) : cb)));
+    server.registerTool = ((name, config, cb) => register(name, {
+        ...config,
+        inputSchema: strictSchemaFor(name, config.inputSchema),
+        outputSchema: withNoticeField(config.outputSchema),
+    }, (config.outputSchema ? withStructuredContent(name, cb) : cb)));
     return server;
 }