@nikolasp98/minion 2026.6.16-dev.20260703022951 → 2026.7.2-dev

package/dist/bundled/boot-md/handler.js

@@ -10655,7 +10655,7 @@ var init_dotenv = __esmMin((() => {
 //#region src/version.ts
 var VERSION;
 var init_version$1 = __esmMin((() => {
-	VERSION = "2026.6.16-dev.20260703022951";
+	VERSION = "2026.7.2-dev";
 }));
 //#endregion
 //#region src/config/agent-dirs.ts
@@ -19704,29 +19704,52 @@ var init__groups_generated = __esmMin((() => {
 		"group:minion": [
 			"agents_list",
 			"architect_pipeline",
+			"booking_cancel",
+			"booking_create",
+			"booking_reschedule",
+			"bookings_query",
+			"brain_remember",
+			"brain_search",
+			"brains_list",
 			"browser",
 			"canvas",
+			"contact_tag",
+			"contact_update",
 			"crm_insight",
 			"crm_query",
 			"crm_search",
 			"cron",
+			"finance_query",
 			"gateway",
 			"gws_auth_revoke",
 			"gws_auth_start",
 			"gws_auth_status",
 			"gws_exec",
+			"hub_pages",
 			"image",
 			"knowledge_graph",
 			"message",
 			"nodes",
+			"notify_user",
+			"order_update_status",
+			"orders_query",
+			"projects_query",
 			"session_status",
 			"sessions_history",
 			"sessions_list",
 			"sessions_send",
 			"sessions_spawn",
 			"skill_view",
+			"stock_entry_create",
+			"stock_query",
 			"subagents",
 			"summarize",
+			"task_create",
+			"task_update",
+			"ticket_comment",
+			"ticket_create",
+			"ticket_update",
+			"tickets_query",
 			"tts",
 			"update_behaviour",
 			"venture_studio",
@@ -28091,16 +28114,26 @@ async function movePathToTrash(targetPath) {
 		await runExec("trash", [targetPath], { timeoutMs: 1e4 });
 		return targetPath;
 	} catch {
-		const trashDir = path.join(os.homedir(), ".Trash");
-		fsSync.mkdirSync(trashDir, { recursive: true });
-		const base = path.basename(targetPath);
-		let dest = path.join(trashDir, `${base}-${Date.now()}`);
-		if (fsSync.existsSync(dest)) dest = path.join(trashDir, `${base}-${Date.now()}-${Math.random()}`);
-		fsSync.renameSync(targetPath, dest);
-		return dest;
+		try {
+			const trashDir = path.join(os.homedir(), ".Trash");
+			fsSync.mkdirSync(trashDir, { recursive: true });
+			const base = path.basename(targetPath);
+			let dest = path.join(trashDir, `${base}-${Date.now()}`);
+			if (fsSync.existsSync(dest)) dest = path.join(trashDir, `${base}-${Date.now()}-${Math.random()}`);
+			fsSync.renameSync(targetPath, dest);
+			return dest;
+		} catch {
+			logWarn(`trash: falling back to fs.rm for "${targetPath}" (trash and rename both failed)`);
+			await fsSync.promises.rm(targetPath, {
+				recursive: true,
+				force: true
+			});
+			return targetPath;
+		}
 	}
 }
 var init_trash = __esmMin((() => {
+	init_logger$2();
 	init_exec();
 }));
 //#endregion
@@ -64347,7 +64380,8 @@ function loadOpenClawPlugins(options = {}) {
 			config: cfg,
 			pluginConfig: validatedConfig.value
 		});
-		const manifestDeclaredChannelLink = Boolean(record.channelLink);
+		const manifestDeclaredChannelLinkMode = record.channelLink?.mode;
+		const manifestDeclaredChannelLink = Boolean(manifestDeclaredChannelLinkMode);
 		try {
 			const result = register(api);
 			if (result && typeof result.then === "function") {
@@ -64362,7 +64396,7 @@ function loadOpenClawPlugins(options = {}) {
 				});
 			}
 			const codeRegisteredChannelLink = Boolean(record.channelLinkRegistered);
-			if (manifestDeclaredChannelLink && !codeRegisteredChannelLink) registry.diagnostics.push({
+			if (manifestDeclaredChannelLink && manifestDeclaredChannelLinkMode !== "managed" && !codeRegisteredChannelLink) registry.diagnostics.push({
 				level: "warn",
 				pluginId: record.id,
 				source: record.source,
@@ -72269,6 +72303,1138 @@ var init_hub_rest_registry = __esmMin((() => {
 	rest = null;
 }));
 //#endregion
+//#region src/agents/tools/hub/hub-common.ts
+/**
+* Shared plumbing for the hub module tool pack (finance/bookings/tickets/
+* orders/projects/pages read tools + booking/ticket/order/task/contact/notify
+* write tools). Mirrors crm_insight/crm_query's gate + fetch shape — do not
+* invent a new one. Gated on (a) a resolved hub REST link and (b) a personal
+* agent id: the hub derives the owning user (and org membership) from
+* `personal-<uuid>`, so a non-personal agent can't use these.
+*/
+function hubToolsAvailable(agentId) {
+	return !!agentId && agentId.startsWith("personal-") && !!getHubRest();
+}
+async function parseResponse(res) {
+	const body = await res.json().catch(() => void 0);
+	if (!res.ok) return { error: (body && typeof body === "object" ? body.error : void 0) ?? `request failed: ${res.status}` };
+	return body ?? {};
+}
+/** GET a `/api/gateway/<path>` endpoint with the trusted agentId + optional orgId. */
+async function hubGet(path, agentId, query = {}) {
+	const rest = getHubRest();
+	if (!rest) return { error: "hub is not connected." };
+	const qs = new URLSearchParams({ agentId });
+	for (const [key, value] of Object.entries(query)) if (value !== void 0) qs.set(key, value);
+	try {
+		return await parseResponse(await fetch(`${rest.hubUrl.replace(/\/$/, "")}/api/gateway/${path}?${qs}`, {
+			method: "GET",
+			headers: { Authorization: `Bearer ${rest.serverToken}` }
+		}));
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+/** POST to a `/api/gateway/<path>` endpoint with the trusted agentId + optional orgId. */
+async function hubPost(path, agentId, body, orgId) {
+	const rest = getHubRest();
+	if (!rest) return { error: "hub is not connected." };
+	const qs = new URLSearchParams({ agentId });
+	if (orgId) qs.set("orgId", orgId);
+	try {
+		return await parseResponse(await fetch(`${rest.hubUrl.replace(/\/$/, "")}/api/gateway/${path}?${qs}`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${rest.serverToken}`,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(body)
+		}));
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+var CONFIRM_FIELD, ORG_ID_FIELD;
+var init_hub_common = __esmMin((() => {
+	init_hub_rest_registry();
+	CONFIRM_FIELD = Type.Boolean({ description: "Required. First present the exact action (entity, fields, effect) to the user and ask for confirmation. Only call with confirm=true after the user explicitly agrees. Calls with confirm=false return a preview, not a mutation." });
+	ORG_ID_FIELD = Type.Optional(Type.String({ description: "Organization id to scope to, ONLY when the page-context envelope gave you an active_org_id and the user has more than one org. Omit otherwise — the hub defaults to the user's primary org. The hub rejects any org the user isn't a member of." }));
+}));
+//#endregion
+//#region src/agents/tools/hub/booking-cancel-tool.ts
+var booking_cancel_tool_exports = /* @__PURE__ */ __exportAll({ createBookingCancelTool: () => createBookingCancelTool });
+/**
+* Cancel an existing booking. WRITE — confirm contract: confirm=false
+* returns a preview, confirm=true only after the user explicitly agrees.
+*/
+function createBookingCancelTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Booking Cancel",
+		name: "booking_cancel",
+		description: "Cancel an existing booking. First present the exact action (which booking) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees.",
+		parameters: BookingCancelSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/booking-cancel", agentId, {
+				bookingId: readStringParam(params, "bookingId", { required: true }),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:booking_cancel");
+}
+var BookingCancelSchema;
+var init_booking_cancel_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BookingCancelSchema = Type.Object({
+		bookingId: Type.String({ description: "The booking to cancel." }),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/booking-create-tool.ts
+var booking_create_tool_exports = /* @__PURE__ */ __exportAll({ createBookingCreateTool: () => createBookingCreateTool });
+/**
+* Create a scheduling booking. WRITE — confirm contract: call with
+* confirm=false first to get a preview of what would be created; only call
+* with confirm=true after the user has explicitly agreed to the exact
+* booking (attendee, time, service).
+*/
+function createBookingCreateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Booking Create",
+		name: "booking_create",
+		description: "Create a new appointment/booking. First present the exact action (attendee, service, start time) to the user and ask for confirmation. Call with confirm=false to get a validated preview (no write); only call with confirm=true after the user explicitly agrees. On success, present the result with a deep link like [booking](/scheduling/bookings?contact={contactId}).",
+		parameters: BookingCreateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/booking-create", agentId, {
+				eventTypeId: readStringParam(params, "eventTypeId", { required: true }),
+				start: readStringParam(params, "start", { required: true }),
+				crmContactId: readStringParam(params, "crmContactId"),
+				attendeeName: readStringParam(params, "attendeeName"),
+				attendeeEmail: readStringParam(params, "attendeeEmail"),
+				attendeePhone: readStringParam(params, "attendeePhone"),
+				resourceId: readStringParam(params, "resourceId"),
+				notes: readStringParam(params, "notes"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:booking_create");
+}
+var BookingCreateSchema;
+var init_booking_create_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BookingCreateSchema = Type.Object({
+		eventTypeId: Type.String({ description: "Which scheduling event type/service to book (required)." }),
+		start: Type.String({ description: "ISO 8601 start time, e.g. 2026-07-10T15:00:00-05:00." }),
+		crmContactId: Type.Optional(Type.String({ description: "CRM contact id, if the attendee is a known contact." })),
+		attendeeName: Type.Optional(Type.String({ description: "Attendee name, required if crmContactId is not known." })),
+		attendeeEmail: Type.Optional(Type.String({ description: "Attendee email address." })),
+		attendeePhone: Type.Optional(Type.String({ description: "Attendee phone number." })),
+		resourceId: Type.Optional(Type.String({ description: "Specific resource/staff id to book, if not left to auto-assign." })),
+		notes: Type.Optional(Type.String({ description: "Free-text booking notes." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/booking-reschedule-tool.ts
+var booking_reschedule_tool_exports = /* @__PURE__ */ __exportAll({ createBookingRescheduleTool: () => createBookingRescheduleTool });
+/**
+* Reschedule an existing booking. The hub implements this as cancel-old +
+* create-new (no atomic "move" service call exists), so this tool must send
+* the FULL new-slot payload — same shape as booking_create — plus the
+* bookingId being cancelled. WRITE — confirm contract: confirm=false returns
+* a preview (cancels + new start), confirm=true only after the user
+* explicitly agrees.
+*/
+function createBookingRescheduleTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Booking Reschedule",
+		name: "booking_reschedule",
+		description: "Move an existing booking to a new time. Under the hood the hub cancels the old booking and creates a new one, so this needs the full new-slot details (event type, start time, attendee), not just a new time. First present the exact change (which booking, old time → new time) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [booking](/scheduling/bookings?contact={contactId}).",
+		parameters: BookingRescheduleSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/booking-reschedule", agentId, {
+				bookingId: readStringParam(params, "bookingId", { required: true }),
+				eventTypeId: readStringParam(params, "eventTypeId", { required: true }),
+				start: readStringParam(params, "start", { required: true }),
+				crmContactId: readStringParam(params, "crmContactId"),
+				attendeeName: readStringParam(params, "attendeeName"),
+				attendeeEmail: readStringParam(params, "attendeeEmail"),
+				attendeePhone: readStringParam(params, "attendeePhone"),
+				resourceId: readStringParam(params, "resourceId"),
+				notes: readStringParam(params, "notes"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:booking_reschedule");
+}
+var BookingRescheduleSchema;
+var init_booking_reschedule_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BookingRescheduleSchema = Type.Object({
+		bookingId: Type.String({ description: "The booking to reschedule (will be cancelled)." }),
+		eventTypeId: Type.String({ description: "Event type/service for the new slot (required)." }),
+		start: Type.String({ description: "New ISO 8601 start time, e.g. 2026-07-10T15:00:00-05:00." }),
+		crmContactId: Type.Optional(Type.String({ description: "CRM contact id, if the attendee is a known contact." })),
+		attendeeName: Type.Optional(Type.String({ description: "Attendee name, required if crmContactId is not known." })),
+		attendeeEmail: Type.Optional(Type.String({ description: "Attendee email address." })),
+		attendeePhone: Type.Optional(Type.String({ description: "Attendee phone number." })),
+		resourceId: Type.Optional(Type.String({ description: "Specific resource/staff id to book, if not left to auto-assign." })),
+		notes: Type.Optional(Type.String({ description: "Free-text booking notes for the new slot." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/bookings-query-tool.ts
+var bookings_query_tool_exports = /* @__PURE__ */ __exportAll({ createBookingsQueryTool: () => createBookingsQueryTool });
+/**
+* Scheduling module read: upcoming/past bookings, optionally filtered by
+* contact or date range. Calls the hub's /api/gateway/query/bookings with
+* the session's personal agent id (org + membership resolved server-side).
+*/
+function createBookingsQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Bookings Query",
+		name: "bookings_query",
+		description: "List appointments/bookings — upcoming, past, or a date range, optionally filtered to one contact. Use for 'what's on the schedule today', 'when is X's next appointment'. To create/change/cancel a booking use booking_create/booking_reschedule/booking_cancel. Present results with a deep link like [bookings](/scheduling/bookings) or, for one contact, [bookings](/scheduling/bookings?contact={contactId}).",
+		parameters: BookingsQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/bookings", agentId, {
+				status: readStringParam(params, "status"),
+				contact: readStringParam(params, "contactId"),
+				from: readStringParam(params, "dateFrom"),
+				to: readStringParam(params, "dateTo"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:bookings_query");
+}
+var BookingsQuerySchema;
+var init_bookings_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BookingsQuerySchema = Type.Object({
+		status: Type.Optional(Type.String({ description: "Comma-separated booking status filter, e.g. 'accepted,pending'. Valid values: accepted | pending | cancelled | rejected | completed | no_show. Omit for all statuses." })),
+		contactId: Type.Optional(Type.String({ description: "Filter to one CRM contact's bookings." })),
+		dateFrom: Type.Optional(Type.String({ description: "ISO date/time, inclusive lower bound on start time." })),
+		dateTo: Type.Optional(Type.String({ description: "ISO date/time, inclusive upper bound on start time." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/brain-remember-tool.ts
+var brain_remember_tool_exports = /* @__PURE__ */ __exportAll({ createBrainRememberTool: () => createBrainRememberTool });
+/**
+* Knowledge-brain module write: add a `note` document to a brain.
+* WRITE — confirm contract: confirm=false returns a preview, confirm=true
+* only after the user explicitly agrees.
+*
+* The hub's /api/gateway/brain-remember endpoint is a plain, idempotent-per-
+* call write with no confirm/preview support of its own (by design — see the
+* hub handler's docstring), so the preview gate is enforced here rather than
+* forwarded like the other write tools.
+*/
+function createBrainRememberTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Brain Remember",
+		name: "brain_remember",
+		description: "Save a note into a knowledge brain. First present the exact action (brain, title, content) and ask for confirmation. Call with confirm=false for a preview (no write); only call with confirm=true after the user explicitly agrees. If you don't already know the brainId, call brains_list first.",
+		parameters: BrainRememberSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const brainId = readStringParam(params, "brainId", { required: true });
+			const title = readStringParam(params, "title", { required: true });
+			const contentMd = readStringParam(params, "contentMd", { required: true });
+			const orgId = readStringParam(params, "orgId");
+			if (params.confirm !== true) return jsonResult({
+				preview: {
+					brainId,
+					title,
+					contentMd
+				},
+				note: "Preview only — not written. Call again with confirm=true after the user agrees."
+			});
+			return jsonResult(await hubPost("brain-remember", agentId, {
+				brainId,
+				title,
+				contentMd
+			}, orgId));
+		}
+	}, "builtin:brain_remember");
+}
+var BrainRememberSchema;
+var init_brain_remember_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BrainRememberSchema = Type.Object({
+		brainId: Type.String({ description: "Brain to write to. If unknown, call brains_list first — do not guess." }),
+		title: Type.String({ description: "Short title for the note document." }),
+		contentMd: Type.String({ description: "Note body, markdown." }),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/brain-search-tool.ts
+var brain_search_tool_exports = /* @__PURE__ */ __exportAll({ createBrainSearchTool: () => createBrainSearchTool });
+/**
+* Knowledge-brain module read: semantic search over one brain's chunks.
+* Calls the hub's /api/gateway/brain-search with the session's personal
+* agent id; per-brain access is enforced again on the hub (fail-closed).
+*/
+function createBrainSearchTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Brain Search",
+		name: "brain_search",
+		description: "Semantic search over one knowledge brain's documents. Requires brainId — if you're not sure which brain to target, call brains_list first rather than guessing. Use for 'what does the X brain say about...' style questions.",
+		parameters: BrainSearchSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("brain-search", agentId, {
+				brainId: readStringParam(params, "brainId", { required: true }),
+				query: readStringParam(params, "query", { required: true }),
+				limit: readNumberParam(params, "limit")
+			}, orgId));
+		}
+	}, "builtin:brain_search");
+}
+var BrainSearchSchema;
+var init_brain_search_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BrainSearchSchema = Type.Object({
+		brainId: Type.String({ description: "Brain to search. If unknown, call brains_list first — do not guess." }),
+		query: Type.String({ description: "Natural-language search query." }),
+		limit: Type.Optional(Type.Number({ description: "Max hits to return. Hub default applies." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/brains-list-tool.ts
+var brains_list_tool_exports = /* @__PURE__ */ __exportAll({ createBrainsListTool: () => createBrainsListTool });
+/**
+* Knowledge-brain module read: list the brains the calling agent's owner can
+* access. Calls the hub's /api/gateway/brains with the session's personal
+* agent id. Call this before brain_search/brain_remember whenever the target
+* brainId isn't already known.
+*/
+function createBrainsListTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Brains List",
+		name: "brains_list",
+		description: "List the knowledge brains available to the current user (id, name, access). Call this first whenever you don't already know which brainId to target for brain_search or brain_remember — do not guess a brainId.",
+		parameters: BrainsListSchema,
+		execute: async (_toolCallId, args) => {
+			return jsonResult(await hubGet("brains", agentId, { orgId: readStringParam(args, "orgId") }));
+		}
+	}, "builtin:brains_list");
+}
+var BrainsListSchema;
+var init_brains_list_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	BrainsListSchema = Type.Object({ orgId: ORG_ID_FIELD });
+}));
+//#endregion
+//#region src/agents/tools/hub/contact-tag-tool.ts
+var contact_tag_tool_exports = /* @__PURE__ */ __exportAll({ createContactTagTool: () => createContactTagTool });
+/**
+* Add or remove a CRM contact tag. WRITE — confirm contract: confirm=false
+* returns a preview, confirm=true only after the user explicitly agrees.
+*/
+function createContactTagTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Contact Tag",
+		name: "contact_tag",
+		description: "Add or remove a tag on a CRM contact by tag NAME (preferred; the hub resolves or creates it) or exact tagId. First present the exact action (contact, tag, add or remove) and ask for confirmation. Call with confirm=false for a validated preview (no write; preview.willCreateTag tells you if a new tag would be created); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [contact](/crm/{contactId}).",
+		parameters: ContactTagSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			const tag = readStringParam(params, "tag");
+			const tagId = readStringParam(params, "tagId");
+			if (!tag && !tagId) return jsonResult({ error: "tag (name) or tagId is required" });
+			return jsonResult(await hubPost("actions/contact-tag", agentId, {
+				contactId: readStringParam(params, "contactId", { required: true }),
+				...tag ? { tag } : {},
+				...tagId ? { tagId } : {},
+				op: readStringParam(params, "op") ?? "add",
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:contact_tag");
+}
+var ContactTagSchema;
+var init_contact_tag_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	ContactTagSchema = Type.Object({
+		contactId: Type.String({ description: "The CRM contact to tag." }),
+		tag: Type.Optional(Type.String({ description: "Tag NAME (case-insensitive). The hub resolves it to an existing tag, or creates a manual tag on 'add'. Preferred over tagId." })),
+		tagId: Type.Optional(Type.String({ description: "Exact tag id — only when you already have it (e.g. from a prior result)." })),
+		op: Type.Optional(Type.Union([Type.Literal("add"), Type.Literal("remove")], { description: "'add' (default) or 'remove'." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/contact-update-tool.ts
+var contact_update_tool_exports = /* @__PURE__ */ __exportAll({ createContactUpdateTool: () => createContactUpdateTool });
+/**
+* Update a CRM contact's name/phone/email/funnel stage/notes. WRITE —
+* confirm contract: confirm=false returns a preview, confirm=true only
+* after the user explicitly agrees. Only whitelisted fields are accepted;
+* use contact_tag for tags, not this tool.
+*/
+function createContactUpdateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Contact Update",
+		name: "contact_update",
+		description: "Update a CRM contact's name, phone, email, funnel stage, or notes (at least one required). First present the exact change (which field, old → new value) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Pass expectedUpdatedAt from the last read to avoid clobbering a concurrent edit (returns {error:'stale',current} on conflict). Use contact_tag to add/remove tags instead. Present the result with a deep link like [contact](/crm/{contactId}).",
+		parameters: ContactUpdateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/contact-update", agentId, {
+				contactId: readStringParam(params, "contactId", { required: true }),
+				name: readStringParam(params, "name"),
+				phone: readStringParam(params, "phone"),
+				email: readStringParam(params, "email"),
+				funnelStage: readStringParam(params, "funnelStage"),
+				notes: readStringParam(params, "notes"),
+				expectedUpdatedAt: readStringParam(params, "expectedUpdatedAt"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:contact_update");
+}
+var ContactUpdateSchema;
+var init_contact_update_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	ContactUpdateSchema = Type.Object({
+		contactId: Type.String({ description: "The CRM contact to update." }),
+		name: Type.Optional(Type.String({ description: "New display name." })),
+		phone: Type.Optional(Type.String({ description: "New phone number." })),
+		email: Type.Optional(Type.String({ description: "New email address." })),
+		funnelStage: Type.Optional(Type.String({ description: "New CRM funnel/lifecycle stage." })),
+		notes: Type.Optional(Type.String({ description: "New/appended free-text notes." })),
+		expectedUpdatedAt: Type.Optional(Type.String({ description: "The contact's updatedAt you last read. Used for optimistic concurrency — the hub rejects the write (409) if the contact changed since." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/finance-query-tool.ts
+var finance_query_tool_exports = /* @__PURE__ */ __exportAll({ createFinanceQueryTool: () => createFinanceQueryTool });
+/**
+* Finance module summary (invoices/payments) for a date range, optionally
+* grouped by product or contact. Calls the hub's Bearer-authed
+* /api/gateway/query/finance with the session's personal agent id; the hub
+* derives the owning user, scopes to their org (membership-checked), and
+* respects the same masking/owner rules the human finance dashboard uses.
+*/
+function createFinanceQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Finance Query",
+		name: "finance_query",
+		description: "Summarize invoices/payments for a date range — totals, payment status, a revenue time series, and top products/clients (always included, no separate breakdown toggle). Use for 'how much revenue this month', 'unpaid invoices', 'top products by revenue in Q1'. For per-customer ranking questions use crm_insight/crm_query instead. Present figures with a deep link like [invoices](/finances/invoices) or, for one contact, [invoices](/finances/invoices?contact={contactId}).",
+		parameters: FinanceQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/finance", agentId, {
+				from: readStringParam(params, "dateFrom"),
+				to: readStringParam(params, "dateTo"),
+				bucket: readStringParam(params, "bucket"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:finance_query");
+}
+var FinanceQuerySchema;
+var init_finance_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	FinanceQuerySchema = Type.Object({
+		dateFrom: Type.Optional(Type.String({ description: "ISO date, inclusive lower bound." })),
+		dateTo: Type.Optional(Type.String({ description: "ISO date, inclusive upper bound." })),
+		bucket: Type.Optional(Type.Union([
+			Type.Literal("day"),
+			Type.Literal("week"),
+			Type.Literal("month")
+		], { description: "Granularity of the revenue time series. Defaults to 'month'." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/hub-pages-tool.ts
+var hub_pages_tool_exports = /* @__PURE__ */ __exportAll({ createHubPagesTool: () => createHubPagesTool });
+/**
+* Discovery tool: fetches the hub's route-hint map from
+* /api/gateway/pages (route, title, what the page shows, accepted query
+* params) so the agent can generate accurate, navigable deep links instead
+* of guessing paths.
+*/
+function createHubPagesTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Hub Pages",
+		name: "hub_pages",
+		description: "List the hub's pages — route, title, what it shows, and query params it accepts. Call this before linking to a page you're not sure about, then present the link as e.g. [invoices](/finances/invoices?contact={contactId}) using the exact path + param names returned here.",
+		parameters: HubPagesSchema,
+		execute: async () => {
+			return jsonResult(await hubGet("pages", agentId));
+		}
+	}, "builtin:hub_pages");
+}
+var HubPagesSchema;
+var init_hub_pages_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	HubPagesSchema = Type.Object({});
+}));
+//#endregion
+//#region src/agents/tools/hub/notify-user-tool.ts
+var notify_user_tool_exports = /* @__PURE__ */ __exportAll({ createNotifyUserTool: () => createNotifyUserTool });
+/**
+* Send a free-text email to an org member. WRITE — confirm contract:
+* confirm=false returns a preview, confirm=true only after the user
+* explicitly agrees. The hub verifies the target is an org member (and has
+* an email on file) before sending; there is no template system and no
+* internal messaging channel — this always sends via email.
+*/
+function createNotifyUserTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Notify User",
+		name: "notify_user",
+		description: "Email a fellow org member (not an external customer) — there is no in-app/SMS channel, this always sends a capped free-text email. First present the exact message and recipient and ask for confirmation. Call with confirm=false for a validated preview (no send); only call with confirm=true after the user explicitly agrees.",
+		parameters: NotifyUserSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/notify-user", agentId, {
+				recipientProfileId: readStringParam(params, "recipientProfileId", { required: true }),
+				subject: readStringParam(params, "subject"),
+				body: readStringParam(params, "body", { required: true }),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:notify_user");
+}
+var NotifyUserSchema;
+var init_notify_user_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	NotifyUserSchema = Type.Object({
+		recipientProfileId: Type.String({ description: "The org member/profile id to notify (must be a member of the org)." }),
+		subject: Type.Optional(Type.String({ description: "Email subject line." })),
+		body: Type.String({ description: "Message body (1-2000 chars). Sent as a capped free-text email." }),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/order-update-status-tool.ts
+var order_update_status_tool_exports = /* @__PURE__ */ __exportAll({ createOrderUpdateStatusTool: () => createOrderUpdateStatusTool });
+/**
+* Change a sales order's status. WRITE — confirm contract: confirm=false
+* returns a preview, confirm=true only after the user explicitly agrees.
+*/
+function createOrderUpdateStatusTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Order Update Status",
+		name: "order_update_status",
+		description: "Change a sales order's status to draft, confirmed, invoiced, or cancelled. First present the exact change (which order, old → new status) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Pass expectedUpdatedAt from the last read to avoid clobbering a concurrent edit. Present the result with a deep link like [order](/sales/{orderId}).",
+		parameters: OrderUpdateStatusSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/order-update-status", agentId, {
+				orderId: readStringParam(params, "orderId", { required: true }),
+				status: readStringParam(params, "status", { required: true }),
+				expectedUpdatedAt: readStringParam(params, "expectedUpdatedAt"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:order_update_status");
+}
+var OrderUpdateStatusSchema;
+var init_order_update_status_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	OrderUpdateStatusSchema = Type.Object({
+		orderId: Type.String({ description: "The sales order to update." }),
+		status: Type.Union([
+			Type.Literal("draft"),
+			Type.Literal("confirmed"),
+			Type.Literal("invoiced"),
+			Type.Literal("cancelled")
+		], { description: "New order status." }),
+		expectedUpdatedAt: Type.Optional(Type.String({ description: "The order's updatedAt you last read (from orders_query). Used for optimistic concurrency — the hub rejects the write (409) if the order changed since." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/orders-query-tool.ts
+var orders_query_tool_exports = /* @__PURE__ */ __exportAll({ createOrdersQueryTool: () => createOrdersQueryTool });
+/**
+* Sales module read: orders by status/date range. Calls the hub's
+* /api/gateway/query/orders with the session's personal agent id.
+*/
+function createOrdersQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Orders Query",
+		name: "orders_query",
+		description: "List sales orders, filterable by status or CRM contact (no date-range filter). Use for 'pending orders', 'open orders'. To change an order's status use order_update_status. Present results with a deep link like [order](/sales/{orderId}).",
+		parameters: OrdersQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/orders", agentId, {
+				status: readStringParam(params, "status"),
+				contact: readStringParam(params, "contactId"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:orders_query");
+}
+var OrdersQuerySchema;
+var init_orders_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	OrdersQuerySchema = Type.Object({
+		status: Type.Optional(Type.Union([
+			Type.Literal("open"),
+			Type.Literal("draft"),
+			Type.Literal("confirmed"),
+			Type.Literal("invoiced"),
+			Type.Literal("cancelled")
+		], { description: "'open' covers all non-terminal statuses (matches the human sales dashboard default)." })),
+		contactId: Type.Optional(Type.String({ description: "Filter to one CRM contact's orders." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/projects-query-tool.ts
+var projects_query_tool_exports = /* @__PURE__ */ __exportAll({ createProjectsQueryTool: () => createProjectsQueryTool });
+/**
+* Projects module read: projects + tasks by status/assignee. Calls the hub's
+* /api/gateway/query/projects with the session's personal agent id.
+*/
+function createProjectsQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Projects Query",
+		name: "projects_query",
+		description: "List projects and their tasks, filterable by project, status, or assignee. Use for 'what's overdue', 'my open tasks', 'status of project X'. To create/update a task use task_create/task_update. Present results with a deep link like [project](/work).",
+		parameters: ProjectsQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/projects", agentId, {
+				projectId: readStringParam(params, "projectId"),
+				status: readStringParam(params, "status"),
+				assignee: readStringParam(params, "assignee"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:projects_query");
+}
+var ProjectsQuerySchema;
+var init_projects_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	ProjectsQuerySchema = Type.Object({
+		projectId: Type.Optional(Type.String({ description: "Filter tasks to one project." })),
+		status: Type.Optional(Type.String({ description: "Project status (open|active|on_hold|completed|cancelled) or task status (backlog|todo|in_progress|in_review|done|blocked|cancelled) filter — applied to whichever list it matches." })),
+		assignee: Type.Optional(Type.String({ description: "Filter tasks by assignee party id." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/stock-entry-create-tool.ts
+var stock_entry_create_tool_exports = /* @__PURE__ */ __exportAll({ createStockEntryCreateTool: () => createStockEntryCreateTool });
+function readLines(params) {
+	return (Array.isArray(params.lines) ? params.lines : []).map((l) => ({
+		itemId: typeof l.itemId === "string" ? l.itemId : "",
+		qty: typeof l.qty === "number" ? l.qty : Number(l.qty),
+		uom: typeof l.uom === "string" ? l.uom : null,
+		rate: typeof l.rate === "number" ? l.rate : l.rate == null ? null : Number(l.rate),
+		fromWarehouseId: typeof l.fromWarehouseId === "string" ? l.fromWarehouseId : null,
+		toWarehouseId: typeof l.toWarehouseId === "string" ? l.toWarehouseId : null
+	}));
+}
+/**
+* Create a DRAFT stock entry. WRITE — confirm contract: confirm=false returns
+* a preview, confirm=true only after the user explicitly agrees. This never
+* submits/posts the entry (that would move stock and write the ledger) —
+* submission is a deliberate separate step done from the hub's /stock UI.
+*/
+function createStockEntryCreateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Stock Entry Create",
+		name: "stock_entry_create",
+		description: "Create a DRAFT stock entry (receipt, issue, transfer, or adjustment) with its lines. This only creates a draft — it does NOT submit/post the entry, so stock levels and the ledger are unaffected until a human submits it from the hub /stock UI. First present the exact action (type, lines, party) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [stock entry](/stock/entries/{entryId}).",
+		parameters: StockEntryCreateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/stock-entry-create", agentId, {
+				type: readStringParam(params, "type", { required: true }),
+				partyId: readStringParam(params, "partyId"),
+				note: readStringParam(params, "note"),
+				lines: readLines(params),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:stock_entry_create");
+}
+var StockEntryLineSchema, StockEntryCreateSchema;
+var init_stock_entry_create_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	StockEntryLineSchema = Type.Object({
+		itemId: Type.String({ description: "Stock item id." }),
+		qty: Type.Number({ description: "Quantity for this line. Must be positive." }),
+		uom: Type.Optional(Type.String({ description: "Unit of measure override." })),
+		rate: Type.Optional(Type.Number({ description: "Per-unit valuation rate. Required for receipt lines and positive adjustments." })),
+		fromWarehouseId: Type.Optional(Type.String({ description: "Source warehouse. Required for issue and transfer lines." })),
+		toWarehouseId: Type.Optional(Type.String({ description: "Destination warehouse. Required for receipt and transfer lines." }))
+	});
+	StockEntryCreateSchema = Type.Object({
+		type: Type.Union([
+			Type.Literal("receipt"),
+			Type.Literal("issue"),
+			Type.Literal("transfer"),
+			Type.Literal("adjustment")
+		], { description: "Entry type." }),
+		partyId: Type.Optional(Type.String({ description: "Supplier/customer party id this entry is for, if known." })),
+		note: Type.Optional(Type.String({ description: "Free-text note." })),
+		lines: Type.Array(StockEntryLineSchema, { description: "One or more entry lines." }),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/stock-query-tool.ts
+var stock_query_tool_exports = /* @__PURE__ */ __exportAll({ createStockQueryTool: () => createStockQueryTool });
+/**
+* Stock module read: bin levels, ledger movements, or valuation totals. Calls
+* the hub's /api/gateway/query/stock with the session's personal agent id.
+*/
+function createStockQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Stock Query",
+		name: "stock_query",
+		description: "Read stock levels, movement history (ledger), or valuation. Use mode='levels' for 'how much of X do we have', mode='movements' with itemId for an item's movement history, mode='valuation' for total stock value. To create a stock entry use stock_entry_create. Present results with a deep link like [stock](/stock).",
+		parameters: StockQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/stock", agentId, {
+				mode: readStringParam(params, "mode"),
+				itemId: readStringParam(params, "itemId"),
+				warehouseId: readStringParam(params, "warehouseId"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:stock_query");
+}
+var StockQuerySchema;
+var init_stock_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	StockQuerySchema = Type.Object({
+		mode: Type.Optional(Type.Union([
+			Type.Literal("levels"),
+			Type.Literal("movements"),
+			Type.Literal("valuation")
+		], { description: "'levels' (default) — current bin quantities. 'movements' — ledger history for one item (itemId required). 'valuation' — bin levels plus the summed stock value." })),
+		itemId: Type.Optional(Type.String({ description: "Filter to one item. Required when mode='movements'." })),
+		warehouseId: Type.Optional(Type.String({ description: "Filter to one warehouse." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/task-create-tool.ts
+var task_create_tool_exports = /* @__PURE__ */ __exportAll({ createTaskCreateTool: () => createTaskCreateTool });
+/**
+* Create a project task. WRITE — confirm contract: confirm=false returns a
+* preview, confirm=true only after the user explicitly agrees.
+*/
+function createTaskCreateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Task Create",
+		name: "task_create",
+		description: "Create a new task under a project. First present the exact action (project, title, assignee, status) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [task](/work).",
+		parameters: TaskCreateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/task-create", agentId, {
+				projectId: readStringParam(params, "projectId", { required: true }),
+				title: readStringParam(params, "title", { required: true }),
+				description: readStringParam(params, "description"),
+				status: readStringParam(params, "status"),
+				priority: readStringParam(params, "priority"),
+				assigneePartyId: readStringParam(params, "assigneePartyId"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:task_create");
+}
+var TaskCreateSchema;
+var init_task_create_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TaskCreateSchema = Type.Object({
+		projectId: Type.String({ description: "The project this task belongs to." }),
+		title: Type.String({ description: "Task title." }),
+		description: Type.Optional(Type.String({ description: "Task description." })),
+		status: Type.Optional(Type.Union([
+			Type.Literal("backlog"),
+			Type.Literal("todo"),
+			Type.Literal("in_progress"),
+			Type.Literal("in_review"),
+			Type.Literal("done"),
+			Type.Literal("blocked"),
+			Type.Literal("cancelled")
+		], { description: "Initial status. Defaults to 'backlog'." })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal("low"),
+			Type.Literal("medium"),
+			Type.Literal("high"),
+			Type.Literal("urgent")
+		], { description: "Task priority." })),
+		assigneePartyId: Type.Optional(Type.String({ description: "Assignee party id." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/task-update-tool.ts
+var task_update_tool_exports = /* @__PURE__ */ __exportAll({ createTaskUpdateTool: () => createTaskUpdateTool });
+/**
+* Update a project task's status/assignee. WRITE — confirm contract:
+* confirm=false returns a preview, confirm=true only after the user
+* explicitly agrees.
+*/
+function createTaskUpdateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Task Update",
+		name: "task_update",
+		description: "Change a task's title, description, status, priority, or assignee. First present the exact change (which task, field, old → new value) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Pass expectedUpdatedAt from the last read to avoid clobbering a concurrent edit. Present the result with a deep link like [task](/work).",
+		parameters: TaskUpdateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/task-update", agentId, {
+				taskId: readStringParam(params, "taskId", { required: true }),
+				title: readStringParam(params, "title"),
+				description: readStringParam(params, "description"),
+				status: readStringParam(params, "status"),
+				priority: readStringParam(params, "priority"),
+				assigneePartyId: readStringParam(params, "assigneePartyId"),
+				expectedUpdatedAt: readStringParam(params, "expectedUpdatedAt"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:task_update");
+}
+var TaskUpdateSchema;
+var init_task_update_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TaskUpdateSchema = Type.Object({
+		taskId: Type.String({ description: "The task to update." }),
+		title: Type.Optional(Type.String({ description: "New title." })),
+		description: Type.Optional(Type.String({ description: "New description." })),
+		status: Type.Optional(Type.Union([
+			Type.Literal("backlog"),
+			Type.Literal("todo"),
+			Type.Literal("in_progress"),
+			Type.Literal("in_review"),
+			Type.Literal("done"),
+			Type.Literal("blocked"),
+			Type.Literal("cancelled")
+		], { description: "New status." })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal("low"),
+			Type.Literal("medium"),
+			Type.Literal("high"),
+			Type.Literal("urgent")
+		], { description: "New priority." })),
+		assigneePartyId: Type.Optional(Type.String({ description: "New assignee party id." })),
+		expectedUpdatedAt: Type.Optional(Type.String({ description: "The task's updatedAt you last read (from projects_query). Used for optimistic concurrency — the hub rejects the write (409) if the task changed since." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/ticket-comment-tool.ts
+var ticket_comment_tool_exports = /* @__PURE__ */ __exportAll({ createTicketCommentTool: () => createTicketCommentTool });
+/**
+* Add a comment to a support ticket's activity log. WRITE — confirm
+* contract: confirm=false returns a preview, confirm=true only after the
+* user explicitly agrees.
+*/
+function createTicketCommentTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Ticket Comment",
+		name: "ticket_comment",
+		description: "Add a comment to a support ticket's activity log. First present the exact comment text and which ticket it goes on, and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [ticket](/support/{ticketId}).",
+		parameters: TicketCommentSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/ticket-comment", agentId, {
+				issueId: readStringParam(params, "issueId", { required: true }),
+				body: readStringParam(params, "body", { required: true }),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:ticket_comment");
+}
+var TicketCommentSchema;
+var init_ticket_comment_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TicketCommentSchema = Type.Object({
+		issueId: Type.String({ description: "The ticket to comment on." }),
+		body: Type.String({ description: "Comment body to add to the ticket's activity log." }),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/ticket-create-tool.ts
+var ticket_create_tool_exports = /* @__PURE__ */ __exportAll({ createTicketCreateTool: () => createTicketCreateTool });
+/**
+* Create a support ticket. WRITE — confirm contract: confirm=false returns
+* a preview, confirm=true only after the user explicitly agrees.
+*/
+function createTicketCreateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Ticket Create",
+		name: "ticket_create",
+		description: "Open a new support ticket. First present the exact action (subject, description, contact, priority) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Present the result with a deep link like [ticket](/support/{ticketId}).",
+		parameters: TicketCreateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/ticket-create", agentId, {
+				subject: readStringParam(params, "subject", { required: true }),
+				description: readStringParam(params, "description"),
+				crmContactId: readStringParam(params, "crmContactId"),
+				partyId: readStringParam(params, "partyId"),
+				priority: readStringParam(params, "priority"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:ticket_create");
+}
+var TicketCreateSchema;
+var init_ticket_create_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TicketCreateSchema = Type.Object({
+		subject: Type.String({ description: "Short ticket subject/title." }),
+		description: Type.Optional(Type.String({ description: "Full issue description." })),
+		crmContactId: Type.Optional(Type.String({ description: "CRM contact this ticket is for, if known." })),
+		partyId: Type.Optional(Type.String({ description: "Party (org member/staff) this ticket is for, if known." })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal("urgent"),
+			Type.Literal("high"),
+			Type.Literal("medium"),
+			Type.Literal("low")
+		], { description: "Priority. Defaults to 'medium'." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/ticket-update-tool.ts
+var ticket_update_tool_exports = /* @__PURE__ */ __exportAll({ createTicketUpdateTool: () => createTicketUpdateTool });
+/**
+* Update a support ticket's status/assignee/priority. WRITE — confirm
+* contract: confirm=false returns a preview, confirm=true only after the
+* user explicitly agrees.
+*/
+function createTicketUpdateTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Ticket Update",
+		name: "ticket_update",
+		description: "Change a support ticket's subject, description, status, owner, or priority. First present the exact change (which ticket, field, old → new value) and ask for confirmation. Call with confirm=false for a validated preview (no write); only call with confirm=true after the user explicitly agrees. Pass expectedUpdatedAt from the last read to avoid clobbering a concurrent edit. Present the result with a deep link like [ticket](/support/{ticketId}).",
+		parameters: TicketUpdateSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const orgId = readStringParam(params, "orgId");
+			return jsonResult(await hubPost("actions/ticket-update", agentId, {
+				issueId: readStringParam(params, "issueId", { required: true }),
+				subject: readStringParam(params, "subject"),
+				description: readStringParam(params, "description"),
+				status: readStringParam(params, "status"),
+				ownerId: readStringParam(params, "ownerId"),
+				priority: readStringParam(params, "priority"),
+				expectedUpdatedAt: readStringParam(params, "expectedUpdatedAt"),
+				confirm: params.confirm === true
+			}, orgId));
+		}
+	}, "builtin:ticket_update");
+}
+var TicketUpdateSchema;
+var init_ticket_update_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TicketUpdateSchema = Type.Object({
+		issueId: Type.String({ description: "The ticket to update." }),
+		subject: Type.Optional(Type.String({ description: "New subject/title." })),
+		description: Type.Optional(Type.String({ description: "New description." })),
+		status: Type.Optional(Type.Union([
+			Type.Literal("open"),
+			Type.Literal("replied"),
+			Type.Literal("on_hold"),
+			Type.Literal("resolved"),
+			Type.Literal("closed")
+		], { description: "New status." })),
+		ownerId: Type.Optional(Type.String({ description: "New owner/assignee party id." })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal("urgent"),
+			Type.Literal("high"),
+			Type.Literal("medium"),
+			Type.Literal("low")
+		], { description: "New priority." })),
+		expectedUpdatedAt: Type.Optional(Type.String({ description: "The ticket's updatedAt you last read (from tickets_query). Used for optimistic concurrency — the hub rejects the write if the ticket changed since." })),
+		confirm: CONFIRM_FIELD,
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
+//#region src/agents/tools/hub/tickets-query-tool.ts
+var tickets_query_tool_exports = /* @__PURE__ */ __exportAll({ createTicketsQueryTool: () => createTicketsQueryTool });
+/**
+* Support module read: tickets by status/assignee/contact. Calls the hub's
+* /api/gateway/query/tickets with the session's personal agent id.
+*/
+function createTicketsQueryTool(options) {
+	const agentId = options.agentId;
+	if (!hubToolsAvailable(agentId)) return null;
+	return wrapToolWithTracking({
+		label: "Tickets Query",
+		name: "tickets_query",
+		description: "List support tickets, filterable by status, priority, or contact. 'Tickets assigned to me' is applied automatically server-side for owner-scoped roles, not via a parameter. Use for 'what's open right now', 'X's open tickets'. To create/update a ticket or add a comment use ticket_create/ticket_update/ticket_comment. Present results with a deep link like [ticket](/support/{ticketId}) or [tickets](/support?contact={contactId}).",
+		parameters: TicketsQuerySchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			return jsonResult(await hubGet("query/tickets", agentId, {
+				status: readStringParam(params, "status"),
+				priority: readStringParam(params, "priority"),
+				contact: readStringParam(params, "contactId"),
+				orgId: readStringParam(params, "orgId")
+			}));
+		}
+	}, "builtin:tickets_query");
+}
+var TicketsQuerySchema;
+var init_tickets_query_tool = __esmMin((() => {
+	init_tool_tracking();
+	init_common();
+	init_hub_common();
+	TicketsQuerySchema = Type.Object({
+		status: Type.Optional(Type.Union([
+			Type.Literal("open"),
+			Type.Literal("replied"),
+			Type.Literal("on_hold"),
+			Type.Literal("resolved"),
+			Type.Literal("closed"),
+			Type.Literal("open_all")
+		], { description: "'open_all' covers open+replied+on_hold in one call. Defaults to 'open_all'." })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal("low"),
+			Type.Literal("medium"),
+			Type.Literal("high"),
+			Type.Literal("urgent")
+		], { description: "Priority filter." })),
+		contactId: Type.Optional(Type.String({ description: "Filter to one CRM contact's tickets." })),
+		orgId: ORG_ID_FIELD
+	});
+}));
+//#endregion
 //#region src/agents/tools/knowledge/crm-insight-tool.ts
 var crm_insight_tool_exports = /* @__PURE__ */ __exportAll({ createCrmInsightTool: () => createCrmInsightTool });
 /**
@@ -87542,6 +88708,349 @@ var init__registry_generated = __esmMin((() => {
 			},
 			load: () => Promise.resolve().then(() => (init_gateway_tool(), gateway_tool_exports))
 		},
+		booking_cancel: {
+			meta: {
+				id: "booking_cancel",
+				factory: "createBookingCancelTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "❌",
+					title: "Booking Cancel",
+					detailKeys: ["bookingId", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_booking_cancel_tool(), booking_cancel_tool_exports))
+		},
+		booking_create: {
+			meta: {
+				id: "booking_create",
+				factory: "createBookingCreateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "📅",
+					title: "Booking Create",
+					detailKeys: ["start", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_booking_create_tool(), booking_create_tool_exports))
+		},
+		booking_reschedule: {
+			meta: {
+				id: "booking_reschedule",
+				factory: "createBookingRescheduleTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🔁",
+					title: "Booking Reschedule",
+					detailKeys: ["bookingId", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_booking_reschedule_tool(), booking_reschedule_tool_exports))
+		},
+		bookings_query: {
+			meta: {
+				id: "bookings_query",
+				factory: "createBookingsQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "📅",
+					title: "Bookings Query",
+					detailKeys: ["status", "contactId"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_bookings_query_tool(), bookings_query_tool_exports))
+		},
+		brain_remember: {
+			meta: {
+				id: "brain_remember",
+				factory: "createBrainRememberTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🧠",
+					title: "Brain Remember",
+					detailKeys: [
+						"brainId",
+						"title",
+						"confirm"
+					]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_brain_remember_tool(), brain_remember_tool_exports))
+		},
+		brain_search: {
+			meta: {
+				id: "brain_search",
+				factory: "createBrainSearchTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🔎",
+					title: "Brain Search",
+					detailKeys: ["brainId", "query"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_brain_search_tool(), brain_search_tool_exports))
+		},
+		brains_list: {
+			meta: {
+				id: "brains_list",
+				factory: "createBrainsListTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🧠",
+					title: "Brains List",
+					detailKeys: ["orgId"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_brains_list_tool(), brains_list_tool_exports))
+		},
+		contact_tag: {
+			meta: {
+				id: "contact_tag",
+				factory: "createContactTagTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🏷️",
+					title: "Contact Tag",
+					detailKeys: [
+						"contactId",
+						"tag",
+						"tagId",
+						"confirm"
+					]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_contact_tag_tool(), contact_tag_tool_exports))
+		},
+		contact_update: {
+			meta: {
+				id: "contact_update",
+				factory: "createContactUpdateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "📇",
+					title: "Contact Update",
+					detailKeys: ["contactId", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_contact_update_tool(), contact_update_tool_exports))
+		},
+		finance_query: {
+			meta: {
+				id: "finance_query",
+				factory: "createFinanceQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "💰",
+					title: "Finance Query",
+					detailKeys: ["dateFrom", "dateTo"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_finance_query_tool(), finance_query_tool_exports))
+		},
+		hub_pages: {
+			meta: {
+				id: "hub_pages",
+				factory: "createHubPagesTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🧭",
+					title: "Hub Pages",
+					detailKeys: []
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_hub_pages_tool(), hub_pages_tool_exports))
+		},
+		notify_user: {
+			meta: {
+				id: "notify_user",
+				factory: "createNotifyUserTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🔔",
+					title: "Notify User",
+					detailKeys: ["recipientProfileId", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_notify_user_tool(), notify_user_tool_exports))
+		},
+		order_update_status: {
+			meta: {
+				id: "order_update_status",
+				factory: "createOrderUpdateStatusTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🛒",
+					title: "Order Update Status",
+					detailKeys: [
+						"orderId",
+						"status",
+						"confirm"
+					]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_order_update_status_tool(), order_update_status_tool_exports))
+		},
+		orders_query: {
+			meta: {
+				id: "orders_query",
+				factory: "createOrdersQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🛒",
+					title: "Orders Query",
+					detailKeys: ["status"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_orders_query_tool(), orders_query_tool_exports))
+		},
+		projects_query: {
+			meta: {
+				id: "projects_query",
+				factory: "createProjectsQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🗂️",
+					title: "Projects Query",
+					detailKeys: ["status", "assignee"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_projects_query_tool(), projects_query_tool_exports))
+		},
+		stock_entry_create: {
+			meta: {
+				id: "stock_entry_create",
+				factory: "createStockEntryCreateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "📦",
+					title: "Stock Entry Create",
+					detailKeys: ["type", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_stock_entry_create_tool(), stock_entry_create_tool_exports))
+		},
+		stock_query: {
+			meta: {
+				id: "stock_query",
+				factory: "createStockQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "📦",
+					title: "Stock Query",
+					detailKeys: ["mode", "itemId"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_stock_query_tool(), stock_query_tool_exports))
+		},
+		task_create: {
+			meta: {
+				id: "task_create",
+				factory: "createTaskCreateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "✅",
+					title: "Task Create",
+					detailKeys: ["title", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_task_create_tool(), task_create_tool_exports))
+		},
+		task_update: {
+			meta: {
+				id: "task_update",
+				factory: "createTaskUpdateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "✅",
+					title: "Task Update",
+					detailKeys: [
+						"taskId",
+						"status",
+						"confirm"
+					]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_task_update_tool(), task_update_tool_exports))
+		},
+		ticket_comment: {
+			meta: {
+				id: "ticket_comment",
+				factory: "createTicketCommentTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "💬",
+					title: "Ticket Comment",
+					detailKeys: ["issueId", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_ticket_comment_tool(), ticket_comment_tool_exports))
+		},
+		ticket_create: {
+			meta: {
+				id: "ticket_create",
+				factory: "createTicketCreateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🎫",
+					title: "Ticket Create",
+					detailKeys: ["subject", "confirm"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_ticket_create_tool(), ticket_create_tool_exports))
+		},
+		ticket_update: {
+			meta: {
+				id: "ticket_update",
+				factory: "createTicketUpdateTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "✏️",
+					title: "Ticket Update",
+					detailKeys: [
+						"issueId",
+						"status",
+						"confirm"
+					]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_ticket_update_tool(), ticket_update_tool_exports))
+		},
+		tickets_query: {
+			meta: {
+				id: "tickets_query",
+				factory: "createTicketsQueryTool",
+				groups: ["group:minion"],
+				display: {
+					emoji: "🎫",
+					title: "Tickets Query",
+					detailKeys: ["status", "priority"]
+				},
+				mcpExport: true
+			},
+			load: () => Promise.resolve().then(() => (init_tickets_query_tool(), tickets_query_tool_exports))
+		},
 		crm_insight: {
 			meta: {
 				id: "crm_insight",
@@ -88498,6 +90007,29 @@ function buildToolOptions(id, ctx) {
 			agentId: ctx.agentId
 		};
 		case "crm_query": return { agentId: ctx.agentId };
+		case "finance_query":
+		case "bookings_query":
+		case "tickets_query":
+		case "orders_query":
+		case "projects_query":
+		case "hub_pages":
+		case "stock_query":
+		case "booking_create":
+		case "booking_reschedule":
+		case "booking_cancel":
+		case "ticket_create":
+		case "ticket_update":
+		case "ticket_comment":
+		case "order_update_status":
+		case "task_create":
+		case "task_update":
+		case "contact_update":
+		case "contact_tag":
+		case "notify_user":
+		case "stock_entry_create":
+		case "brains_list":
+		case "brain_search":
+		case "brain_remember": return { agentId: ctx.agentId };
 		default: return;
 	}
 }
@@ -88603,7 +90135,30 @@ var init_minion_tools = __esmMin((() => {
 		"summarize",
 		"crm_search",
 		"crm_insight",
-		"crm_query"
+		"crm_query",
+		"finance_query",
+		"bookings_query",
+		"tickets_query",
+		"orders_query",
+		"projects_query",
+		"hub_pages",
+		"stock_query",
+		"booking_create",
+		"booking_reschedule",
+		"booking_cancel",
+		"ticket_create",
+		"ticket_update",
+		"ticket_comment",
+		"order_update_status",
+		"task_create",
+		"task_update",
+		"contact_update",
+		"contact_tag",
+		"notify_user",
+		"stock_entry_create",
+		"brains_list",
+		"brain_search",
+		"brain_remember"
 	];
 }));
 //#endregion