@chronary/toolkit 0.1.3 → 1.1.0

package/dist/index.cjs

@@ -41,166 +41,372 @@ var TOOL_NAMES = [
   "get_event",
   "create_event",
   "update_event",
-  "delete_event",
-  "check_availability",
+  "cancel_event",
+  "confirm_event",
+  "release_event",
+  "create_agent",
+  "list_agents",
+  "get_agent",
+  "update_agent",
+  "delete_agent",
+  "get_availability",
+  "find_meeting_time",
+  "get_calendar_context",
+  "create_proposal",
+  "list_proposals",
+  "get_proposal",
+  "respond_to_proposal",
+  "resolve_proposal",
+  "cancel_proposal",
+  "set_availability_rules",
+  "get_availability_rules",
+  "clear_availability_rules",
   "list_webhooks",
   "get_webhook",
   "create_webhook",
   "update_webhook",
   "delete_webhook",
+  "list_webhook_deliveries",
   "list_ical_subscriptions",
   "get_ical_subscription",
-  "create_ical_subscription",
+  "subscribe_ical",
   "update_ical_subscription",
   "delete_ical_subscription",
   "sync_ical_subscription",
+  "create_scoped_key",
+  "list_scoped_keys",
+  "revoke_scoped_key",
+  "get_audit_log",
+  "accept_terms",
   "get_usage"
 ];
 
 // src/schemas.ts
 var schemas_exports = {};
 __export(schemas_exports, {
-  CheckAvailabilitySchema: () => CheckAvailabilitySchema,
+  AcceptTermsSchema: () => AcceptTermsSchema,
+  CancelEventSchema: () => CancelEventSchema,
+  CancelProposalSchema: () => CancelProposalSchema,
+  ClearAvailabilityRulesSchema: () => ClearAvailabilityRulesSchema,
+  ConfirmEventSchema: () => ConfirmEventSchema,
+  CreateAgentSchema: () => CreateAgentSchema,
   CreateCalendarSchema: () => CreateCalendarSchema,
   CreateEventSchema: () => CreateEventSchema,
-  CreateICalSubscriptionSchema: () => CreateICalSubscriptionSchema,
+  CreateProposalSchema: () => CreateProposalSchema,
+  CreateScopedKeySchema: () => CreateScopedKeySchema,
   CreateWebhookSchema: () => CreateWebhookSchema,
+  DeleteAgentSchema: () => DeleteAgentSchema,
   DeleteCalendarSchema: () => DeleteCalendarSchema,
-  DeleteEventSchema: () => DeleteEventSchema,
   DeleteICalSubscriptionSchema: () => DeleteICalSubscriptionSchema,
   DeleteWebhookSchema: () => DeleteWebhookSchema,
+  FindMeetingTimeSchema: () => FindMeetingTimeSchema,
+  GetAgentSchema: () => GetAgentSchema,
+  GetAuditLogSchema: () => GetAuditLogSchema,
+  GetAvailabilityRulesSchema: () => GetAvailabilityRulesSchema,
+  GetAvailabilitySchema: () => GetAvailabilitySchema,
+  GetCalendarContextSchema: () => GetCalendarContextSchema,
   GetCalendarSchema: () => GetCalendarSchema,
   GetEventSchema: () => GetEventSchema,
   GetICalSubscriptionSchema: () => GetICalSubscriptionSchema,
+  GetProposalSchema: () => GetProposalSchema,
   GetUsageSchema: () => GetUsageSchema,
   GetWebhookSchema: () => GetWebhookSchema,
+  ListAgentsSchema: () => ListAgentsSchema,
   ListCalendarsSchema: () => ListCalendarsSchema,
   ListEventsSchema: () => ListEventsSchema,
   ListICalSubscriptionsSchema: () => ListICalSubscriptionsSchema,
+  ListProposalsSchema: () => ListProposalsSchema,
+  ListScopedKeysSchema: () => ListScopedKeysSchema,
+  ListWebhookDeliveriesSchema: () => ListWebhookDeliveriesSchema,
   ListWebhooksSchema: () => ListWebhooksSchema,
+  ReleaseEventSchema: () => ReleaseEventSchema,
+  ResolveProposalSchema: () => ResolveProposalSchema,
+  RespondToProposalSchema: () => RespondToProposalSchema,
+  RevokeScopedKeySchema: () => RevokeScopedKeySchema,
+  SetAvailabilityRulesSchema: () => SetAvailabilityRulesSchema,
+  SubscribeICalSchema: () => SubscribeICalSchema,
   SyncICalSubscriptionSchema: () => SyncICalSubscriptionSchema,
+  UpdateAgentSchema: () => UpdateAgentSchema,
   UpdateCalendarSchema: () => UpdateCalendarSchema,
   UpdateEventSchema: () => UpdateEventSchema,
   UpdateICalSubscriptionSchema: () => UpdateICalSubscriptionSchema,
   UpdateWebhookSchema: () => UpdateWebhookSchema
 });
 var import_zod = require("zod");
+var WEBHOOK_EVENT_TYPES = [
+  "agent.created",
+  "agent.updated",
+  "event.created",
+  "event.updated",
+  "event.deleted",
+  "event.started",
+  "event.ended",
+  "event.reminder",
+  "event.hold_created",
+  "event.hold_expired",
+  "event.hold_released",
+  "event.hold_confirmed",
+  "proposal.created",
+  "proposal.responded",
+  "proposal.confirmed",
+  "proposal.expired",
+  "proposal.cancelled",
+  "webhook.deactivated"
+];
+var WEBHOOK_DELIVERY_STATUSES = ["pending", "delivered", "failed"];
 var ListCalendarsSchema = import_zod.z.object({
-  agent_id: import_zod.z.string().optional().describe("Filter calendars by agent ID"),
-  include: import_zod.z.enum(["all"]).optional().describe('Set to "all" to include soft-deleted calendars'),
-  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results per page (default 50)"),
-  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
+  include: import_zod.z.enum(["all"]).optional().describe('Pass "all" to include calendars across all agents (org keys only)'),
+  limit: import_zod.z.number().int().min(1).max(200).default(50).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset")
 });
 var GetCalendarSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("The calendar ID to retrieve")
+  calendar_id: import_zod.z.string().describe("Calendar ID to fetch")
 });
 var CreateCalendarSchema = import_zod.z.object({
-  name: import_zod.z.string().describe("Calendar name"),
-  timezone: import_zod.z.string().describe('IANA timezone (e.g., "America/New_York")'),
-  agent_id: import_zod.z.string().optional().describe("Agent ID to associate the calendar with"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
+  name: import_zod.z.string().min(1).max(255).describe("Calendar name"),
+  agent_id: import_zod.z.string().optional().describe("Agent ID to own this calendar (omit for org-level)"),
+  timezone: import_zod.z.string().min(1).describe("IANA timezone (e.g. America/New_York)"),
+  default_reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Default reminder offsets in minutes before start, inherited by events on this calendar that don't set their own. Omit or null to use the system default (10 min); [] for no reminders.")
 });
 var UpdateCalendarSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("The calendar ID to update"),
-  name: import_zod.z.string().optional().describe("New calendar name"),
-  timezone: import_zod.z.string().optional().describe("New IANA timezone"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Updated metadata")
+  calendar_id: import_zod.z.string().describe("Calendar ID to update"),
+  name: import_zod.z.string().min(1).max(255).optional().describe("New calendar name"),
+  timezone: import_zod.z.string().min(1).optional().describe("New IANA timezone (e.g. America/New_York)"),
+  agent_status: import_zod.z.enum(["idle", "working", "waiting", "error"]).optional().describe("Owning agent's status"),
+  default_reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Default reminder offsets in minutes; null for system default, [] for none"),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary metadata (max 16KB)")
 });
 var DeleteCalendarSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("The calendar ID to delete")
+  calendar_id: import_zod.z.string().describe("Calendar ID to delete")
 });
 var ListEventsSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().optional().describe("Calendar ID to list events from (provide this or agent_id)"),
-  agent_id: import_zod.z.string().optional().describe("Agent ID to list events for (provide this or calendar_id)"),
-  start_after: import_zod.z.string().optional().describe("Only events starting after this ISO 8601 datetime"),
-  start_before: import_zod.z.string().optional().describe("Only events starting before this ISO 8601 datetime"),
-  status: import_zod.z.enum(["confirmed", "tentative", "cancelled"]).optional().describe("Filter by event status"),
-  source: import_zod.z.enum(["internal", "external_ical"]).optional().describe("Filter by event source"),
-  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results per page (default 50)"),
-  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
+  calendar_id: import_zod.z.string().describe("Calendar ID to list events from"),
+  start_after: import_zod.z.string().datetime().optional().describe("Filter events starting after this time"),
+  start_before: import_zod.z.string().datetime().optional().describe("Filter events starting before this time"),
+  limit: import_zod.z.number().int().min(1).max(200).default(50).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset")
 });
 var GetEventSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("Calendar ID the event belongs to"),
-  event_id: import_zod.z.string().describe("The event ID to retrieve")
+  event_id: import_zod.z.string().describe("Event ID to retrieve"),
+  calendar_id: import_zod.z.string().describe("Calendar ID that owns the event. Required \u2014 the SDK is calendar-scoped (unlike the hosted MCP, which can resolve the calendar from event_id).")
 });
 var CreateEventSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("Calendar ID to create the event on"),
-  title: import_zod.z.string().describe("Event title"),
-  start_time: import_zod.z.string().describe("Start time in ISO 8601 format"),
-  end_time: import_zod.z.string().describe("End time in ISO 8601 format"),
-  description: import_zod.z.string().optional().describe("Event description"),
-  all_day: import_zod.z.boolean().optional().describe("Whether this is an all-day event"),
-  status: import_zod.z.enum(["confirmed", "tentative", "cancelled"]).optional().describe('Event status (default "confirmed")'),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
+  calendar_id: import_zod.z.string().describe("Calendar ID to add the event to"),
+  title: import_zod.z.string().min(1).max(500).describe("Event title"),
+  start_time: import_zod.z.string().datetime().describe("Start time (ISO 8601)"),
+  end_time: import_zod.z.string().datetime().describe("End time (ISO 8601)"),
+  description: import_zod.z.string().optional().describe("Optional event description"),
+  all_day: import_zod.z.boolean().default(false).describe("Whether this is an all-day event"),
+  status: import_zod.z.enum(["confirmed", "tentative", "hold"]).optional().describe('Event status. "hold" creates a tentative reservation that auto-expires at hold_expires_at. Defaults to "confirmed".'),
+  reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Reminder offsets in minutes before start_time (e.g. [10, 1440]). Each fires an event.reminder webhook and shows as an alarm in the iCal feed. Omit or null to inherit the calendar default (then the system default of 10 min); [] for no reminders."),
+  hold_expires_at: import_zod.z.string().datetime().optional().describe('Required when status="hold". ISO 8601 timestamp 30s-15min in the future. Auto-releases the hold when reached.'),
+  hold_priority: import_zod.z.number().int().min(0).max(100).optional().describe('Only valid with status="hold". Higher-priority overlapping holds pre-empt lower-priority ones. Defaults to 0.')
 });
 var UpdateEventSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("Calendar ID the event belongs to"),
-  event_id: import_zod.z.string().describe("The event ID to update"),
-  title: import_zod.z.string().optional().describe("New event title"),
-  description: import_zod.z.string().nullable().optional().describe("New description (null to clear)"),
-  start_time: import_zod.z.string().optional().describe("New start time in ISO 8601 format"),
-  end_time: import_zod.z.string().optional().describe("New end time in ISO 8601 format"),
+  event_id: import_zod.z.string().describe("Event ID to update"),
+  calendar_id: import_zod.z.string().describe("Calendar ID that owns the event. Required \u2014 the SDK is calendar-scoped (unlike the hosted MCP, which can resolve the calendar from event_id)."),
+  title: import_zod.z.string().min(1).max(500).optional().describe("New event title"),
+  description: import_zod.z.string().nullable().optional().describe("New description, or null to clear it"),
+  start_time: import_zod.z.string().datetime().optional().describe("New start time (ISO 8601)"),
+  end_time: import_zod.z.string().datetime().optional().describe("New end time (ISO 8601)"),
   all_day: import_zod.z.boolean().optional().describe("Whether this is an all-day event"),
   status: import_zod.z.enum(["confirmed", "tentative", "cancelled"]).optional().describe("New event status"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Updated metadata")
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Replacement metadata object"),
+  reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Reminder offsets in minutes before start_time. Omit to leave unchanged, null to inherit the calendar default, [] for no reminders.")
 });
-var DeleteEventSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("Calendar ID the event belongs to"),
-  event_id: import_zod.z.string().describe("The event ID to delete")
+var CancelEventSchema = import_zod.z.object({
+  event_id: import_zod.z.string().describe("Event ID to cancel"),
+  calendar_id: import_zod.z.string().describe("Calendar ID that owns the event. Required \u2014 the SDK is calendar-scoped (unlike the hosted MCP, which can resolve the calendar from event_id).")
 });
-var CheckAvailabilitySchema = import_zod.z.object({
-  agents: import_zod.z.array(import_zod.z.string()).min(1).describe("Agent IDs to check availability for"),
-  start: import_zod.z.string().describe("Start of time range in ISO 8601 format"),
-  end: import_zod.z.string().describe("End of time range in ISO 8601 format"),
-  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).optional().describe('Duration of availability slots (default "30m")'),
-  calendars: import_zod.z.array(import_zod.z.string()).optional().describe("Specific calendar IDs to check (default: all agent calendars)"),
-  include_busy: import_zod.z.boolean().optional().describe("Include busy blocks in response")
+var ConfirmEventSchema = import_zod.z.object({
+  event_id: import_zod.z.string().describe("Event ID of the hold to confirm")
 });
-var ListWebhooksSchema = import_zod.z.object({
-  limit: import_zod.z.number().int().min(1).max(100).optional().describe("Max results per page (default 20)"),
+var ReleaseEventSchema = import_zod.z.object({
+  event_id: import_zod.z.string().describe("Event ID of the hold to release")
+});
+var CreateAgentSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(255).describe("Display name for the agent"),
+  type: import_zod.z.enum(["ai", "human", "resource"]).describe("Agent type"),
+  description: import_zod.z.string().optional().describe("Optional description")
+});
+var ListAgentsSchema = import_zod.z.object({
+  type: import_zod.z.enum(["ai", "human", "resource"]).optional().describe("Filter by agent type"),
+  status: import_zod.z.enum(["active", "paused", "decommissioned"]).optional().describe("Filter by status"),
+  limit: import_zod.z.number().int().min(1).max(200).default(50).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset")
+});
+var GetAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to fetch")
+});
+var UpdateAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to update"),
+  name: import_zod.z.string().min(1).max(255).optional().describe("New display name"),
+  description: import_zod.z.string().nullable().optional().describe("New description (null to clear)"),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary metadata (max 16KB)"),
+  status: import_zod.z.enum(["active", "paused"]).optional().describe("Operational status")
+});
+var DeleteAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to decommission")
+});
+var GetAvailabilitySchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to check availability for"),
+  start: import_zod.z.string().datetime().optional().describe("Range start (ISO 8601). Alias: start_time."),
+  end: import_zod.z.string().datetime().optional().describe("Range end (ISO 8601). Alias: end_time."),
+  start_time: import_zod.z.string().datetime().optional().describe("Alias for `start` (matches REST events naming)."),
+  end_time: import_zod.z.string().datetime().optional().describe("Alias for `end` (matches REST events naming)."),
+  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).default("30m").describe("Minimum slot duration required \u2014 only free blocks at least this long are returned"),
+  include_busy: import_zod.z.boolean().default(false).describe("Include busy blocks in response")
+});
+var FindMeetingTimeSchema = import_zod.z.object({
+  agents: import_zod.z.array(import_zod.z.string()).min(1).optional().describe("Array of agent IDs to find common free time for. All agents must be free during the returned slots. Alias: agent_ids."),
+  agent_ids: import_zod.z.array(import_zod.z.string()).min(1).optional().describe("Alias for `agents` (matches REST/scheduling-proposal naming)."),
+  start: import_zod.z.string().datetime().optional().describe("Search range start (ISO 8601). Alias: start_time."),
+  end: import_zod.z.string().datetime().optional().describe("Search range end (ISO 8601). Alias: end_time."),
+  start_time: import_zod.z.string().datetime().optional().describe("Alias for `start` (matches REST events naming)."),
+  end_time: import_zod.z.string().datetime().optional().describe("Alias for `end` (matches REST events naming)."),
+  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).default("30m").describe("Minimum slot duration required \u2014 only free blocks at least this long are returned"),
+  calendars: import_zod.z.array(import_zod.z.string()).optional().describe("Additional shared calendar IDs to treat as busy"),
+  include_busy: import_zod.z.boolean().default(false).describe("Include per-agent busy blocks in response")
+});
+var GetCalendarContextSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar ID")
+});
+var proposalSlotSchema = import_zod.z.object({
+  start_time: import_zod.z.string().datetime(),
+  end_time: import_zod.z.string().datetime(),
+  weight: import_zod.z.number().min(0).max(10).default(1).optional(),
+  calendar_id: import_zod.z.string().optional()
+});
+var CreateProposalSchema = import_zod.z.object({
+  title: import_zod.z.string().min(1).max(500).describe("Short description of what the meeting is about"),
+  description: import_zod.z.string().max(5e3).optional().describe("Longer context/agenda"),
+  organizer_agent_id: import_zod.z.string().describe("Agent ID proposing the meeting"),
+  participant_agent_ids: import_zod.z.array(import_zod.z.string()).min(1).max(50).describe("Agent IDs invited to respond"),
+  calendar_id: import_zod.z.string().describe("Calendar the resolved event will be created on"),
+  slots: import_zod.z.array(proposalSlotSchema).min(1).max(20).describe("Candidate time slots (up to 20)"),
+  expires_at: import_zod.z.string().datetime().optional().describe("Auto-cancel cutoff if unresolved")
+});
+var ListProposalsSchema = import_zod.z.object({
+  status: import_zod.z.enum(["pending", "confirmed", "expired", "cancelled"]).optional().describe("Filter by proposal status"),
+  organizer_agent_id: import_zod.z.string().optional().describe("Filter by organizer agent"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results (default 50)"),
   offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
 });
+var GetProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to fetch")
+});
+var RespondToProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to respond to"),
+  agent_id: import_zod.z.string().describe("Participant agent responding"),
+  response: import_zod.z.enum(["accept", "decline", "counter"]).describe("Decision from this agent"),
+  selected_slot_id: import_zod.z.string().optional().describe('Required when response is "accept"'),
+  counter_slots: import_zod.z.array(proposalSlotSchema).max(20).optional().describe('Alternative slots when response is "counter"'),
+  message: import_zod.z.string().max(2e3).optional().describe("Optional note for the organizer")
+});
+var ResolveProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to resolve")
+});
+var CancelProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to cancel")
+});
+var timeOfDay = import_zod.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM in 24-hour time");
+var workingHoursDaySchema = import_zod.z.object({
+  start: timeOfDay,
+  end: timeOfDay
+});
+var workingHoursSchema = import_zod.z.object({
+  mon: workingHoursDaySchema.optional(),
+  tue: workingHoursDaySchema.optional(),
+  wed: workingHoursDaySchema.optional(),
+  thu: workingHoursDaySchema.optional(),
+  fri: workingHoursDaySchema.optional(),
+  sat: workingHoursDaySchema.optional(),
+  sun: workingHoursDaySchema.optional()
+}).nullable();
+var SetAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar to configure"),
+  buffer_before_minutes: import_zod.z.number().int().min(0).max(120).default(0).describe("Minutes of buffer before each event (0\u2013120)"),
+  buffer_after_minutes: import_zod.z.number().int().min(0).max(120).default(0).describe("Minutes of buffer after each event (0\u2013120)"),
+  working_hours: workingHoursSchema.default(null).describe("Per-day working hours map in the calendar's timezone; omit keys for off-days. Pass null to remove any working-hours constraint."),
+  timezone: import_zod.z.string().min(1).max(64).default("UTC").describe("IANA timezone used to interpret working_hours (e.g. America/New_York)")
+});
+var GetAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar to read")
+});
+var ClearAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar whose rules should be cleared")
+});
+var CreateScopedKeySchema = import_zod.z.object({
+  agent_id: import_zod.z.string().regex(/^agt_/).describe("Agent ID this key is scoped to"),
+  label: import_zod.z.string().min(1).max(100).optional().describe("Human-readable label for the key")
+});
+var ListScopedKeysSchema = import_zod.z.object({});
+var RevokeScopedKeySchema = import_zod.z.object({
+  key_id: import_zod.z.string().describe("ID of the scoped key to revoke")
+});
+var GetAuditLogSchema = import_zod.z.object({
+  from: import_zod.z.string().datetime({ offset: true }).optional().describe("Start of the window (ISO 8601). Silently clamped to the plan retention window if older."),
+  to: import_zod.z.string().datetime({ offset: true }).optional().describe("End of the window (ISO 8601)"),
+  action: import_zod.z.string().min(1).max(64).optional().describe("Filter by action name (e.g. event.created)"),
+  actor_key_prefix: import_zod.z.string().min(1).max(32).optional().describe("Filter by the API key prefix that performed the action"),
+  cursor: import_zod.z.string().min(1).max(256).optional().describe("Opaque pagination cursor from a previous response"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results to return (default 50)")
+});
+var AcceptTermsSchema = import_zod.z.object({
+  tos_version: import_zod.z.string().min(1).describe("The terms-of-service version to accept; must match the current version")
+});
+var ListWebhooksSchema = import_zod.z.object({
+  limit: import_zod.z.number().int().min(1).max(100).default(20).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset")
+});
 var GetWebhookSchema = import_zod.z.object({
-  webhook_id: import_zod.z.string().describe("The webhook ID to retrieve")
+  webhook_id: import_zod.z.string().describe("Webhook subscription to fetch")
 });
 var CreateWebhookSchema = import_zod.z.object({
-  url: import_zod.z.string().describe("HTTPS URL to receive webhook payloads"),
-  events: import_zod.z.array(import_zod.z.string()).describe('Event types to subscribe to (e.g., ["event.created", "event.updated"])')
+  url: import_zod.z.string().url().describe("HTTPS endpoint that will receive event deliveries"),
+  events: import_zod.z.array(import_zod.z.enum(WEBHOOK_EVENT_TYPES)).min(1).describe("Event types to subscribe to")
 });
 var UpdateWebhookSchema = import_zod.z.object({
-  webhook_id: import_zod.z.string().describe("The webhook ID to update"),
-  url: import_zod.z.string().optional().describe("New webhook URL"),
-  events: import_zod.z.array(import_zod.z.string()).optional().describe("New event type subscriptions"),
-  active: import_zod.z.boolean().optional().describe("Enable or disable the webhook")
+  webhook_id: import_zod.z.string().describe("Webhook subscription to update"),
+  url: import_zod.z.string().url().optional().describe("New HTTPS delivery endpoint"),
+  events: import_zod.z.array(import_zod.z.enum(WEBHOOK_EVENT_TYPES)).min(1).optional().describe("Replacement set of event types to subscribe to"),
+  active: import_zod.z.boolean().optional().describe("Set false to pause deliveries, true to resume")
 });
 var DeleteWebhookSchema = import_zod.z.object({
-  webhook_id: import_zod.z.string().describe("The webhook ID to delete")
+  webhook_id: import_zod.z.string().describe("Webhook subscription to delete")
+});
+var ListWebhookDeliveriesSchema = import_zod.z.object({
+  webhook_id: import_zod.z.string().describe("Webhook subscription whose deliveries to list"),
+  limit: import_zod.z.number().int().min(1).max(100).default(20).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset"),
+  status: import_zod.z.enum(WEBHOOK_DELIVERY_STATUSES).optional().describe("Filter to a single delivery status"),
+  include_payload: import_zod.z.boolean().optional().describe("Include the full event payload sent on each delivery")
 });
 var ListICalSubscriptionsSchema = import_zod.z.object({
-  agent_id: import_zod.z.string().describe("Agent ID to list subscriptions for"),
+  agent_id: import_zod.z.string().describe("Agent ID whose iCal subscriptions to list"),
   status: import_zod.z.enum(["active", "error", "paused"]).optional().describe("Filter by subscription status"),
-  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results per page (default 50)"),
-  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
+  limit: import_zod.z.number().int().min(1).max(200).default(50).describe("Max results to return"),
+  offset: import_zod.z.number().int().min(0).default(0).describe("Pagination offset")
 });
 var GetICalSubscriptionSchema = import_zod.z.object({
-  subscription_id: import_zod.z.string().describe("The iCal subscription ID to retrieve")
+  subscription_id: import_zod.z.string().describe("iCal subscription ID to fetch")
 });
-var CreateICalSubscriptionSchema = import_zod.z.object({
-  agent_id: import_zod.z.string().describe("Agent ID to create the subscription for"),
-  calendar_id: import_zod.z.string().describe("Calendar ID to import events into"),
-  url: import_zod.z.string().describe("HTTPS URL of the iCal feed to subscribe to"),
-  label: import_zod.z.string().optional().describe("Human-readable label for the subscription")
+var SubscribeICalSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID that will own this subscription"),
+  calendar_id: import_zod.z.string().describe("Calendar ID to sync external events into"),
+  url: import_zod.z.string().url().describe("HTTPS URL of the iCal feed (.ics) to subscribe to"),
+  label: import_zod.z.string().optional().describe("Optional label for this subscription")
 });
 var UpdateICalSubscriptionSchema = import_zod.z.object({
-  subscription_id: import_zod.z.string().describe("The iCal subscription ID to update"),
-  label: import_zod.z.string().optional().describe("New label"),
-  url: import_zod.z.string().optional().describe("New iCal feed URL")
+  subscription_id: import_zod.z.string().describe("iCal subscription ID to update"),
+  label: import_zod.z.string().min(1).max(255).optional().describe("New label for this subscription"),
+  url: import_zod.z.string().url().startsWith("https://", "URL must use HTTPS").optional().describe("New HTTPS URL of the iCal feed (.ics)")
 });
 var DeleteICalSubscriptionSchema = import_zod.z.object({
-  subscription_id: import_zod.z.string().describe("The iCal subscription ID to delete")
+  subscription_id: import_zod.z.string().describe("iCal subscription ID to delete")
 });
 var SyncICalSubscriptionSchema = import_zod.z.object({
-  subscription_id: import_zod.z.string().describe("The iCal subscription ID to sync immediately")
+  subscription_id: import_zod.z.string().describe("iCal subscription ID to sync")
 });
 var GetUsageSchema = import_zod.z.object({});
 
@@ -230,7 +436,7 @@ async function fetchPage(iterator, offset, limit) {
 }
 var listCalendars = safeFunc(async (ctx) => {
   const { client, params } = ctx;
-  const iter = client.calendars.list({ agentId: params.agent_id, include: params.include, limit: params.limit });
+  const iter = client.calendars.list({ include: params.include, limit: params.limit });
   return fetchPage(iter, params.offset, params.limit);
 });
 var getCalendar = safeFunc(async (ctx) => {
@@ -242,6 +448,7 @@ var createCalendar = safeFunc(async (ctx) => {
     name: params.name,
     timezone: params.timezone,
     agentId: params.agent_id,
+    default_reminders: params.default_reminders,
     metadata: params.metadata
   });
 });
@@ -258,11 +465,8 @@ var listEvents = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const iter = client.events.list({
     calendarId: params.calendar_id,
-    agentId: params.agent_id,
     start_after: params.start_after,
     start_before: params.start_before,
-    status: params.status,
-    source: params.source,
     limit: params.limit
   });
   return fetchPage(iter, params.offset, params.limit);
@@ -280,12 +484,117 @@ var updateEvent = safeFunc(async (ctx) => {
   const { calendar_id, event_id, ...updates } = params;
   return client.events.update(calendar_id, event_id, updates);
 });
-var deleteEvent = safeFunc(async (ctx) => {
+var cancelEvent = safeFunc(async (ctx) => {
   await ctx.client.events.delete(ctx.params.calendar_id, ctx.params.event_id);
   return void 0;
 });
-var checkAvailability = safeFunc(async (ctx) => {
-  return ctx.client.availability.check(ctx.params);
+var confirmEvent = safeFunc(async (ctx) => {
+  return ctx.client.events.confirm(ctx.params.event_id);
+});
+var releaseEvent = safeFunc(async (ctx) => {
+  return ctx.client.events.release(ctx.params.event_id);
+});
+var createAgent = safeFunc(async (ctx) => {
+  return ctx.client.agents.create(ctx.params);
+});
+var listAgents = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const iter = client.agents.list({ type: params.type, status: params.status, limit: params.limit });
+  return fetchPage(iter, params.offset, params.limit);
+});
+var getAgent = safeFunc(async (ctx) => {
+  return ctx.client.agents.get(ctx.params.agent_id);
+});
+var updateAgent = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { agent_id, ...updates } = params;
+  return client.agents.update(agent_id, updates);
+});
+var deleteAgent = safeFunc(async (ctx) => {
+  await ctx.client.agents.delete(ctx.params.agent_id);
+  return void 0;
+});
+var getAvailability = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const start = params.start ?? params.start_time;
+  const end = params.end ?? params.end_time;
+  if (!start || !end) {
+    throw new Error("start (or start_time) and end (or end_time) are required");
+  }
+  return client.availability.forAgent(params.agent_id, {
+    start,
+    end,
+    slot_duration: params.slot_duration,
+    include_busy: params.include_busy
+  });
+});
+var findMeetingTime = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const agents = params.agents ?? params.agent_ids;
+  const start = params.start ?? params.start_time;
+  const end = params.end ?? params.end_time;
+  if (!agents || !start || !end) {
+    throw new Error("agents (or agent_ids), start (or start_time), and end (or end_time) are required");
+  }
+  return client.availability.check({
+    agents,
+    start,
+    end,
+    slot_duration: params.slot_duration,
+    calendars: params.calendars,
+    include_busy: params.include_busy
+  });
+});
+var getCalendarContext = safeFunc(async (ctx) => {
+  return ctx.client.calendars.getContext(ctx.params.calendar_id);
+});
+var createProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.create(ctx.params);
+});
+var listProposals = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const iter = client.scheduling.list({
+    status: params.status,
+    organizer_agent_id: params.organizer_agent_id,
+    limit: params.limit
+  });
+  return fetchPage(iter, params.offset, params.limit);
+});
+var getProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.get(ctx.params.proposal_id);
+});
+var respondToProposal = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { proposal_id, ...body } = params;
+  return client.scheduling.respond(proposal_id, body);
+});
+var resolveProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.resolve(ctx.params.proposal_id);
+});
+var cancelProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.cancel(ctx.params.proposal_id);
+});
+var setAvailabilityRules = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { calendar_id, ...rules } = params;
+  return client.calendars.setAvailabilityRules(calendar_id, rules);
+});
+var getAvailabilityRules = safeFunc(async (ctx) => {
+  return ctx.client.calendars.getAvailabilityRules(ctx.params.calendar_id);
+});
+var clearAvailabilityRules = safeFunc(async (ctx) => {
+  await ctx.client.calendars.deleteAvailabilityRules(ctx.params.calendar_id);
+  return void 0;
+});
+var createScopedKey = safeFunc(async (ctx) => {
+  return ctx.client.keys.create(ctx.params);
+});
+var listScopedKeys = safeFunc(async (ctx) => {
+  return ctx.client.keys.list();
+});
+var revokeScopedKey = safeFunc(async (ctx) => {
+  await ctx.client.keys.delete(ctx.params.key_id);
+  return void 0;
 });
 var listWebhooks = safeFunc(async (ctx) => {
   const { client, params } = ctx;
@@ -307,6 +616,17 @@ var deleteWebhook = safeFunc(async (ctx) => {
   await ctx.client.webhooks.delete(ctx.params.webhook_id);
   return void 0;
 });
+var listWebhookDeliveries = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { webhook_id, ...query } = params;
+  return client.webhooks.listDeliveries(webhook_id, query);
+});
+var getAuditLog = safeFunc(async (ctx) => {
+  return ctx.client.auditLog.list(ctx.params);
+});
+var acceptTerms = safeFunc(async (ctx) => {
+  return ctx.client.terms.accept(ctx.params);
+});
 var listICalSubscriptions = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const iter = client.icalSubscriptions.list({
@@ -319,7 +639,7 @@ var listICalSubscriptions = safeFunc(async (ctx) => {
 var getICalSubscription = safeFunc(async (ctx) => {
   return ctx.client.icalSubscriptions.get(ctx.params.subscription_id);
 });
-var createICalSubscription = safeFunc(async (ctx) => {
+var subscribeICal = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const { agent_id, ...subParams } = params;
   return client.icalSubscriptions.create(agent_id, subParams);
@@ -350,12 +670,19 @@ var HOSTED_API_MCP_TOOL_NAMES = [
   "create_calendar",
   "create_event",
   "list_events",
+  "get_event",
+  "update_event",
   "get_availability",
   "find_meeting_time",
   "cancel_event",
   "confirm_event",
   "release_event",
   "subscribe_ical",
+  "list_ical_subscriptions",
+  "get_ical_subscription",
+  "update_ical_subscription",
+  "delete_ical_subscription",
+  "sync_ical_subscription",
   "get_calendar_context",
   "create_proposal",
   "list_proposals",
@@ -365,41 +692,60 @@ var HOSTED_API_MCP_TOOL_NAMES = [
   "cancel_proposal",
   "set_availability_rules",
   "get_availability_rules",
-  "clear_availability_rules"
+  "clear_availability_rules",
+  "create_scoped_key",
+  "list_scoped_keys",
+  "revoke_scoped_key",
+  "create_webhook",
+  "list_webhooks",
+  "get_webhook",
+  "update_webhook",
+  "delete_webhook",
+  "list_webhook_deliveries",
+  "get_agent",
+  "update_agent",
+  "delete_agent",
+  "list_calendars",
+  "get_calendar",
+  "update_calendar",
+  "delete_calendar",
+  "get_usage",
+  "get_audit_log",
+  "accept_terms"
 ];
 var TOOL_DEFINITIONS = [
   // ── Calendars ──────────────────────────────────────────────────
   {
     name: "list_calendars",
-    description: "List calendars, optionally filtered by agent. Returns paginated results.",
+    description: "List calendars in the org. Org-level API keys see every calendar (agent-owned and shared); agent-scoped keys see only their own agent's calendars. Use this to discover calendar IDs before creating or listing events.",
     schema: ListCalendarsSchema,
     annotations: { title: "List Calendars", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(listCalendars)
   },
   {
     name: "get_calendar",
-    description: "Get a calendar by its ID, including its name, timezone, and iCal feed URL.",
+    description: "Fetch a single calendar by ID, including its name, timezone, agent status, and default reminders. Agent-scoped keys may only read calendars owned by their agent.",
     schema: GetCalendarSchema,
     annotations: { title: "Get Calendar", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(getCalendar)
   },
   {
     name: "create_calendar",
-    description: "Create a new calendar. Specify a name and IANA timezone. Optionally scope it to an agent.",
+    description: 'Create a calendar to hold events and track availability. Calendars are required before creating events \u2014 call this first when setting up a new agent. An agent can have multiple calendars (e.g. "Work", "Personal"). Org-level calendars (no agent_id) can be used as shared resources like meeting rooms.',
     schema: CreateCalendarSchema,
     annotations: { title: "Create Calendar", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     execute: createExecutor(createCalendar)
   },
   {
     name: "update_calendar",
-    description: "Update a calendar's name, timezone, or metadata.",
+    description: "Update a calendar's name, timezone, agent status, default reminders, or metadata. Agent-scoped keys may only update calendars owned by their agent.",
     schema: UpdateCalendarSchema,
     annotations: { title: "Update Calendar", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(updateCalendar)
   },
   {
     name: "delete_calendar",
-    description: "Permanently delete a calendar and all its events.",
+    description: "Delete a calendar (soft delete). Its events are no longer returned and it stops contributing to availability. Agent-scoped keys may only delete calendars owned by their agent.",
     schema: DeleteCalendarSchema,
     annotations: { title: "Delete Calendar", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(deleteCalendar)
@@ -407,130 +753,305 @@ var TOOL_DEFINITIONS = [
   // ── Events ─────────────────────────────────────────────────────
   {
     name: "list_events",
-    description: "List events on a calendar or for an agent. Supports date range and status filters. Provide calendar_id or agent_id.",
+    description: "List all events on a calendar, including internally created events and externally synced events from iCal subscriptions (e.g. Google Calendar, Outlook). Use start_after and start_before to query a specific time window.",
     schema: ListEventsSchema,
     annotations: { title: "List Events", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(listEvents)
   },
   {
     name: "get_event",
-    description: "Get a specific event by its calendar ID and event ID.",
+    description: "Retrieve a single event by ID, including its title, times, status, location, reminders, and metadata. Works for both internally created events and externally synced iCal events. `calendar_id` is optional \u2014 if omitted the calendar is resolved from the event. Provide `calendar_id` to fail fast on cross-calendar typos.",
     schema: GetEventSchema,
     annotations: { title: "Get Event", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(getEvent)
   },
   {
     name: "create_event",
-    description: "Create a new event on a calendar. The event blocks the agent's availability during the specified time window and appears in availability queries.",
+    description: `Create a booking, appointment, meeting, hold, or any scheduled event on a calendar. The calendar_id comes from create_calendar or list_events. Once created, this event blocks the agent's availability during that time and appears in availability queries. Use status="hold" with hold_expires_at to tentatively reserve a slot that auto-releases on TTL.`,
     schema: CreateEventSchema,
     annotations: { title: "Create Event", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     execute: createExecutor(createEvent)
   },
   {
     name: "update_event",
-    description: "Update an existing event's title, times, status, or other properties.",
+    description: "Reschedule or edit an event \u2014 change its title, description, start/end times, location, status, reminders, or metadata. Use this to move an appointment to a new time or update its details. Provide only the fields you want to change. Holds cannot be edited via this tool (use confirm_event / release_event). External iCal events are read-only. `calendar_id` is optional \u2014 if omitted it is resolved from the event.",
     schema: UpdateEventSchema,
     annotations: { title: "Update Event", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(updateEvent)
   },
   {
-    name: "delete_event",
-    description: "Delete an event from a calendar. This frees the agent's availability during that time.",
-    schema: DeleteEventSchema,
-    annotations: { title: "Delete Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
-    execute: createExecutor(deleteEvent)
+    name: "cancel_event",
+    description: "Delete or cancel an event from a calendar. Use this to remove, cancel, or delete any scheduled event or appointment. The event is marked cancelled and excluded from future availability calculations. `calendar_id` is optional \u2014 if omitted the calendar is looked up from the event. Provide `calendar_id` to fail fast on cross-calendar typos.",
+    schema: CancelEventSchema,
+    annotations: { title: "Cancel Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(cancelEvent)
+  },
+  {
+    name: "confirm_event",
+    description: 'Promote a held event to a confirmed booking. The event must currently have status="hold" and its hold_expires_at must not have passed. After confirmation, event.started and event.ended lifecycle webhooks fire at the scheduled times.',
+    schema: ConfirmEventSchema,
+    annotations: { title: "Confirm Event", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(confirmEvent)
+  },
+  {
+    name: "release_event",
+    description: 'Manually release a held event before its hold_expires_at. The event must currently have status="hold". Frees the slot for other agents to book.',
+    schema: ReleaseEventSchema,
+    annotations: { title: "Release Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(releaseEvent)
+  },
+  // ── Agents ─────────────────────────────────────────────────────
+  {
+    name: "create_agent",
+    description: "Register your agent (AI assistant, human participant, or resource) with Chronary so it can own calendars, events, and webhooks.",
+    schema: CreateAgentSchema,
+    annotations: { title: "Create Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createAgent)
+  },
+  {
+    name: "list_agents",
+    description: "List all agents in your organization",
+    schema: ListAgentsSchema,
+    annotations: { title: "List Agents", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listAgents)
+  },
+  {
+    name: "get_agent",
+    description: "Fetch a single agent by ID. An agent represents an AI assistant, human, or shared resource (e.g. a meeting room). Agent-scoped API keys may only read their own agent.",
+    schema: GetAgentSchema,
+    annotations: { title: "Get Agent", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAgent)
+  },
+  {
+    name: "update_agent",
+    description: "Update an agent's name, description, metadata, or status (active/paused). Requires an org-level API key \u2014 agent-scoped keys cannot mutate agents.",
+    schema: UpdateAgentSchema,
+    annotations: { title: "Update Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(updateAgent)
+  },
+  {
+    name: "delete_agent",
+    description: "Decommission an agent. This marks the agent as decommissioned and revokes all of its scoped API keys. Requires an org-level API key \u2014 agent-scoped keys cannot delete agents.",
+    schema: DeleteAgentSchema,
+    annotations: { title: "Delete Agent", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(deleteAgent)
   },
   // ── Availability ───────────────────────────────────────────────
   {
-    name: "check_availability",
-    description: "Check free/busy availability across one or more agents within a time range. Returns available time slots and optionally busy blocks.",
-    schema: CheckAvailabilitySchema,
-    annotations: { title: "Check Availability", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    execute: createExecutor(checkAvailability)
+    name: "get_availability",
+    description: "Check when a single agent is free within a time range. Accepts `start`/`end` (preferred \u2014 matches the underlying availability service) or `start_time`/`end_time` (aliases that match the REST events schema).",
+    schema: GetAvailabilitySchema,
+    annotations: { title: "Get Availability", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAvailability)
+  },
+  {
+    name: "find_meeting_time",
+    description: "Find time slots when multiple agents are all free simultaneously. Accepts `agents`/`start`/`end` (preferred \u2014 matches the availability service) or `agent_ids`/`start_time`/`end_time` (aliases that match the REST/scheduling-proposal naming).",
+    schema: FindMeetingTimeSchema,
+    annotations: { title: "Find Meeting Time", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(findMeetingTime)
+  },
+  // ── Calendar context ───────────────────────────────────────────
+  {
+    name: "get_calendar_context",
+    description: `Get a calendar's temporal context in a single call: the current event (if one is happening now), the next upcoming event, recent past events, a short upcoming window, and the owning agent's status (idle/working/waiting/error). Use this to answer "what is this agent doing right now?" without issuing multiple list_events queries.`,
+    schema: GetCalendarContextSchema,
+    annotations: { title: "Get Calendar Context", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getCalendarContext)
+  },
+  // ── Scheduling proposals ───────────────────────────────────────
+  {
+    name: "create_proposal",
+    description: "Create a scheduling proposal \u2014 send a set of candidate time slots to one or more participant agents so they can accept, decline, or counter-propose. The organizer agent owns the proposal; once every participant responds, the system auto-resolves to the highest-scoring slot (or cancels if all decline). Requires an org-level API key. Pro plan only.",
+    schema: CreateProposalSchema,
+    annotations: { title: "Create Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createProposal)
+  },
+  {
+    name: "list_proposals",
+    description: "List scheduling proposals for the org. Filter by status (pending|confirmed|expired|cancelled) or organizer_agent_id. Requires an org-level API key.",
+    schema: ListProposalsSchema,
+    annotations: { title: "List Proposals", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listProposals)
+  },
+  {
+    name: "get_proposal",
+    description: "Get a scheduling proposal by id, including its slots and per-participant responses. Requires an org-level API key.",
+    schema: GetProposalSchema,
+    annotations: { title: "Get Proposal", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getProposal)
+  },
+  {
+    name: "respond_to_proposal",
+    description: 'Submit a response (accept / decline / counter) on behalf of one participant agent to an open proposal. An "accept" requires the slot id from the proposal; a "counter" can suggest alternative slots. When all participants have responded the proposal auto-resolves \u2014 no separate resolve call needed in the normal flow. Requires an org-level API key. Pro plan only.',
+    schema: RespondToProposalSchema,
+    annotations: { title: "Respond To Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(respondToProposal)
+  },
+  {
+    name: "resolve_proposal",
+    description: 'Force-resolve an open proposal using responses collected so far. Picks the highest-scoring slot among those accepted by the most participants and creates a confirmed calendar event. If every response was "decline", the proposal is cancelled instead. Use when you want to close out a proposal without waiting for every participant. Requires an org-level API key. Pro plan only.',
+    schema: ResolveProposalSchema,
+    annotations: { title: "Resolve Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(resolveProposal)
+  },
+  {
+    name: "cancel_proposal",
+    description: 'Cancel an open proposal. Fires a proposal.cancelled webhook with reason="organizer_cancelled". Requires an org-level API key. Pro plan only.',
+    schema: CancelProposalSchema,
+    annotations: { title: "Cancel Proposal", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(cancelProposal)
+  },
+  // ── Availability rules ─────────────────────────────────────────
+  {
+    name: "set_availability_rules",
+    description: "Set or replace the availability rules on a calendar \u2014 buffer times before/after events and optional per-day working hours. When these rules are set, every availability query on this calendar automatically applies them (busy-block expansion for buffers, masking outside working hours). Upsert: overwrites any existing rules.",
+    schema: SetAvailabilityRulesSchema,
+    annotations: { title: "Set Availability Rules", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(setAvailabilityRules)
+  },
+  {
+    name: "get_availability_rules",
+    description: "Read the buffer times and working-hours rules configured on a calendar. Returns the rules row, or an error if none are set.",
+    schema: GetAvailabilityRulesSchema,
+    annotations: { title: "Get Availability Rules", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAvailabilityRules)
+  },
+  {
+    name: "clear_availability_rules",
+    description: "Remove the availability rules from a calendar, reverting to the default (no buffers, no working-hours mask). Returns the deleted row, or an error if none were set.",
+    schema: ClearAvailabilityRulesSchema,
+    annotations: { title: "Clear Availability Rules", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(clearAvailabilityRules)
   },
   // ── Webhooks ───────────────────────────────────────────────────
   {
     name: "list_webhooks",
-    description: "List all webhook subscriptions for the organization.",
+    description: "List the org's webhook subscriptions with their subscribed event types and active state. Signing secrets are never returned. Requires an org-level API key.",
     schema: ListWebhooksSchema,
     annotations: { title: "List Webhooks", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(listWebhooks)
   },
   {
     name: "get_webhook",
-    description: "Get a webhook subscription by its ID.",
+    description: "Get a single webhook subscription by id, including its subscribed event types and active state. The signing secret is never returned. Requires an org-level API key.",
     schema: GetWebhookSchema,
     annotations: { title: "Get Webhook", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(getWebhook)
   },
   {
     name: "create_webhook",
-    description: "Create a webhook subscription to receive event notifications at a URL. Payloads are signed with HMAC-SHA256.",
+    description: "Create a webhook subscription so the org receives HTTP POST notifications when events occur (e.g. event.created, proposal.confirmed). The signing secret is returned ONCE in this response \u2014 store it to verify the HMAC-SHA256 signature on delivered payloads. Requires an org-level API key.",
     schema: CreateWebhookSchema,
     annotations: { title: "Create Webhook", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     execute: createExecutor(createWebhook)
   },
   {
     name: "update_webhook",
-    description: "Update a webhook's URL, subscribed events, or active status.",
+    description: "Update a webhook subscription \u2014 change its delivery URL, the set of subscribed event types, or pause/resume it via active. At least one field must be supplied. Requires an org-level API key.",
     schema: UpdateWebhookSchema,
     annotations: { title: "Update Webhook", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(updateWebhook)
   },
   {
     name: "delete_webhook",
-    description: "Delete a webhook subscription. No further events will be delivered to this URL.",
+    description: "Permanently delete a webhook subscription. This frees its endpoint slot against the per-plan cap. Requires an org-level API key.",
     schema: DeleteWebhookSchema,
     annotations: { title: "Delete Webhook", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(deleteWebhook)
   },
+  {
+    name: "list_webhook_deliveries",
+    description: "List delivery attempts for a webhook subscription, with per-status counts (pending/delivered/failed). Use this to debug failing deliveries. Requires an org-level API key.",
+    schema: ListWebhookDeliveriesSchema,
+    annotations: { title: "List Webhook Deliveries", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listWebhookDeliveries)
+  },
   // ── iCal Subscriptions ─────────────────────────────────────────
   {
     name: "list_ical_subscriptions",
-    description: "List external calendar imports (iCal subscriptions) for an agent.",
+    description: "List an agent's external iCal feed subscriptions (e.g. linked Google Calendar / Outlook feeds), including their sync status and last sync time.",
     schema: ListICalSubscriptionsSchema,
     annotations: { title: "List iCal Subscriptions", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(listICalSubscriptions)
   },
   {
     name: "get_ical_subscription",
-    description: "Get an iCal subscription by its ID, including sync status and last error.",
+    description: "Get a single external iCal feed subscription by id, including its sync status, last sync time, and last error.",
     schema: GetICalSubscriptionSchema,
     annotations: { title: "Get iCal Subscription", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(getICalSubscription)
   },
   {
-    name: "create_ical_subscription",
-    description: "Import an external calendar by subscribing to an iCal feed URL. Events are synced every 30 minutes.",
-    schema: CreateICalSubscriptionSchema,
-    annotations: { title: "Create iCal Subscription", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    execute: createExecutor(createICalSubscription)
+    name: "subscribe_ical",
+    description: "Link an external iCal feed (e.g. a human's Google Calendar) to an agent's calendar so external events appear in availability calculations. The target calendar must be owned by the specified agent \u2014 create the calendar with that agent_id first (org-level calendars without an agent_id cannot host external iCal subscriptions; create a dedicated per-agent calendar for sync targets).",
+    schema: SubscribeICalSchema,
+    annotations: { title: "Subscribe iCal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    execute: createExecutor(subscribeICal)
   },
   {
     name: "update_ical_subscription",
-    description: "Update an iCal subscription's label or feed URL.",
+    description: "Update an external iCal feed subscription \u2014 change its label or its feed URL. Changing the URL forces a full re-sync on the next poll.",
     schema: UpdateICalSubscriptionSchema,
     annotations: { title: "Update iCal Subscription", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(updateICalSubscription)
   },
   {
     name: "delete_ical_subscription",
-    description: "Remove an external calendar import. Previously synced events remain on the calendar.",
+    description: "Delete an external iCal feed subscription. Events previously synced from the feed are no longer refreshed.",
     schema: DeleteICalSubscriptionSchema,
     annotations: { title: "Delete iCal Subscription", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(deleteICalSubscription)
   },
   {
     name: "sync_ical_subscription",
-    description: "Trigger an immediate sync of an iCal subscription instead of waiting for the next 30-minute poll.",
+    description: "Trigger an immediate sync of an external iCal feed subscription instead of waiting for the next scheduled poll. Returns once the sync has been queued.",
     schema: SyncICalSubscriptionSchema,
     annotations: { title: "Sync iCal Subscription", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     execute: createExecutor(syncICalSubscription)
   },
+  // ── Scoped keys ────────────────────────────────────────────────
+  {
+    name: "create_scoped_key",
+    description: "Create an agent-scoped API key (chr_ak_*) that can only act on behalf of a single agent. Use this to self-provision or rotate per-agent credentials. The plaintext key is returned exactly once in the response \u2014 store it immediately, it cannot be retrieved later. Requires an org-level API key.",
+    schema: CreateScopedKeySchema,
+    annotations: { title: "Create Scoped Key", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createScopedKey)
+  },
+  {
+    name: "list_scoped_keys",
+    description: "List all live (non-revoked) agent-scoped API keys for this org. Returns key metadata only (id, prefix, agent_id, label, created_at) \u2014 never the plaintext secret. Requires an org-level API key.",
+    schema: ListScopedKeysSchema,
+    annotations: { title: "List Scoped Keys", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listScopedKeys)
+  },
+  {
+    name: "revoke_scoped_key",
+    description: "Revoke an agent-scoped API key by ID. The key stops authenticating immediately and cannot be un-revoked. Requires an org-level API key.",
+    schema: RevokeScopedKeySchema,
+    annotations: { title: "Revoke Scoped Key", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(revokeScopedKey)
+  },
+  // ── Audit log ──────────────────────────────────────────────────
+  {
+    name: "get_audit_log",
+    description: "List audit-log entries for the calling org \u2014 mutating operations and auth-lifecycle events, newest first. Results are clamped to the plan's retention window. Requires an org-level API key (chr_sk_*); agent-scoped keys cannot read the org-wide audit log.",
+    schema: GetAuditLogSchema,
+    annotations: { title: "Get Audit Log", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAuditLog)
+  },
+  // ── Terms ──────────────────────────────────────────────────────
+  {
+    name: "accept_terms",
+    description: "Re-accept the current Chronary terms of service on behalf of the calling org. Use this when responses carry the Chronary-Terms-Upgrade-Required header \u2014 a material ToS bump otherwise leaves MCP-only agents stuck without a console session. Pass the current tos_version (read it from GET /v1/auth/terms/current). Requires an org-level API key (chr_sk_*); agent-scoped keys cannot accept org-wide terms.",
+    schema: AcceptTermsSchema,
+    annotations: { title: "Accept Terms", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(acceptTerms)
+  },
   // ── Usage ──────────────────────────────────────────────────────
   {
     name: "get_usage",
-    description: "Get quota and usage statistics for the current billing period.",
+    description: "Get the calling org's current-period usage and plan limits (agents, calendars, events, API calls, webhooks, availability queries, iCal subscriptions, proposals, scoped keys, holds, cross-calendar queries). Requires an org-level API key (chr_sk_*); agent-scoped keys cannot read org-wide usage.",
     schema: GetUsageSchema,
     annotations: { title: "Get Usage", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(getUsage)