kantban-cli 0.1.15 → 0.1.16

package/dist/chunk-MN4H5NSU.js

@@ -0,0 +1,3149 @@
+// src/lib/gate-config.ts
+import { load, JSON_SCHEMA } from "js-yaml";
+
+// ../types/dist/api-response.js
+import { z } from "zod";
+var ApiErrorSchema = z.object({
+  success: z.literal(false),
+  error: z.object({ code: z.string(), message: z.string() })
+});
+
+// ../types/dist/common.js
+import { z as z2 } from "zod";
+var IdSchema = z2.string().uuid();
+var SortOrderSchema = z2.enum(["asc", "desc"]);
+var PaginationParamsSchema = z2.object({
+  page: z2.coerce.number().int().min(1).default(1),
+  limit: z2.coerce.number().int().min(1).max(100).default(20),
+  sort_by: z2.string().optional(),
+  sort_order: SortOrderSchema.default("asc")
+});
+var TimestampsSchema = z2.object({
+  created_at: z2.string().datetime({ offset: true }),
+  updated_at: z2.string().datetime({ offset: true })
+});
+
+// ../types/dist/user.schema.js
+import { z as z3 } from "zod";
+var UserProfileSchema = z3.object({
+  id: z3.string().uuid(),
+  display_name: z3.string().min(1),
+  avatar_url: z3.string().url().nullable(),
+  created_at: z3.string().datetime({ offset: true }),
+  updated_at: z3.string().datetime({ offset: true })
+});
+var CreateUserProfileSchema = z3.object({
+  display_name: z3.string().min(1),
+  avatar_url: z3.string().url().nullable().optional()
+});
+var UpdateUserProfileSchema = z3.object({
+  display_name: z3.string().min(1).optional(),
+  avatar_url: z3.string().url().nullable().optional()
+});
+
+// ../types/dist/project.schema.js
+import { z as z4 } from "zod";
+
+// ../types/dist/palette.js
+var PALETTE_KEYS = [
+  "red-500",
+  "orange-500",
+  "amber-500",
+  "yellow-500",
+  "lime-500",
+  "green-500",
+  "emerald-500",
+  "teal-500",
+  "cyan-500",
+  "sky-500",
+  "blue-500",
+  "indigo-500",
+  "violet-500",
+  "purple-500",
+  "fuchsia-500",
+  "pink-500",
+  "rose-500",
+  "stone-500",
+  "zinc-500"
+];
+
+// ../types/dist/project.schema.js
+var ProjectRoleSchema = z4.enum(["owner", "admin", "editor", "viewer"]);
+var ProjectSchema = z4.object({
+  id: z4.string().uuid(),
+  name: z4.string().min(1),
+  owner_id: z4.string().uuid(),
+  icon: z4.string().nullable().default(null),
+  color: z4.string().nullable().default(null),
+  ticket_prefix: z4.string().regex(/^[A-Z]{2,10}$/),
+  ticket_counter: z4.number().int().nonnegative(),
+  created_at: z4.string().datetime({ offset: true }),
+  updated_at: z4.string().datetime({ offset: true })
+});
+var ProjectWithRoleSchema = ProjectSchema.extend({
+  role: ProjectRoleSchema
+});
+var CreateProjectSchema = z4.object({
+  name: z4.string().trim().min(1).max(100),
+  ticket_prefix: z4.string().regex(/^[A-Z]{2,10}$/)
+});
+var IconSchema = z4.string().min(1).refine((val) => val.length <= 3 || val.includes("/") || val.includes("."), "Must be 1-3 character initials or a storage path");
+var UpdateProjectSchema = z4.object({
+  name: z4.string().trim().min(1).max(100).optional(),
+  icon: IconSchema.nullable().optional(),
+  color: z4.enum(PALETTE_KEYS).nullable().optional(),
+  ticket_prefix: z4.string().regex(/^[A-Z]{2,10}$/).optional()
+});
+var DeleteProjectPreviewSchema = z4.object({
+  boards: z4.number().int().nonnegative(),
+  tickets: z4.number().int().nonnegative(),
+  documents: z4.number().int().nonnegative(),
+  doc_spaces: z4.number().int().nonnegative(),
+  fields: z4.number().int().nonnegative(),
+  members: z4.number().int().nonnegative(),
+  conversations: z4.number().int().nonnegative()
+});
+
+// ../types/dist/project-member.schema.js
+import { z as z5 } from "zod";
+var ProjectMemberSchema = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  user_id: z5.string().uuid(),
+  role: ProjectRoleSchema,
+  created_at: z5.string().datetime({ offset: true }),
+  updated_at: z5.string().datetime({ offset: true })
+});
+var ProjectMemberWithProfileSchema = ProjectMemberSchema.extend({
+  user: UserProfileSchema
+});
+var UpdateProjectMemberSchema = z5.object({
+  role: z5.enum(["admin", "editor", "viewer"])
+});
+
+// ../types/dist/project-invitation.schema.js
+import { z as z6 } from "zod";
+var InvitationStatusSchema = z6.enum(["pending", "accepted", "declined", "revoked"]);
+var ProjectInvitationSchema = z6.object({
+  id: z6.string().uuid(),
+  project_id: z6.string().uuid(),
+  invited_by: z6.string().uuid(),
+  email: z6.string().email(),
+  role: z6.enum(["admin", "editor", "viewer"]),
+  token: z6.string(),
+  status: InvitationStatusSchema,
+  expires_at: z6.string().datetime({ offset: true }),
+  created_at: z6.string().datetime({ offset: true }),
+  updated_at: z6.string().datetime({ offset: true })
+});
+var ProjectInvitationWithInviterSchema = ProjectInvitationSchema.extend({
+  inviter: UserProfileSchema
+});
+var CreateProjectInvitationSchema = z6.object({
+  email: z6.string().email(),
+  role: z6.enum(["admin", "editor", "viewer"]).default("editor")
+});
+
+// ../types/dist/board.schema.js
+import { z as z8 } from "zod";
+
+// ../types/dist/board-member.schema.js
+import { z as z7 } from "zod";
+var BoardRoleSchema = z7.enum(["owner", "admin", "editor", "viewer"]);
+var BoardMemberSchema = z7.object({
+  id: z7.string().uuid(),
+  board_id: z7.string().uuid(),
+  user_id: z7.string().uuid(),
+  role: BoardRoleSchema,
+  created_at: z7.string().datetime({ offset: true }),
+  updated_at: z7.string().datetime({ offset: true })
+});
+var BoardMemberWithProfileSchema = BoardMemberSchema.extend({
+  user: UserProfileSchema
+});
+var UpdateBoardMemberSchema = z7.object({
+  role: z7.enum(["admin", "editor", "viewer"])
+});
+var AddBoardMemberSchema = z7.object({
+  user_id: z7.string().uuid(),
+  role: z7.enum(["admin", "editor", "viewer"])
+});
+
+// ../types/dist/board.schema.js
+var BoardVisibilitySchema = z8.enum(["public", "private"]);
+var BoardSchema = z8.object({
+  id: z8.string().uuid(),
+  project_id: z8.string().uuid(),
+  name: z8.string().min(1),
+  visibility: BoardVisibilitySchema,
+  icon: z8.string().nullable().default(null),
+  color: z8.string().nullable().default(null),
+  circuit_breaker_threshold: z8.number().int().positive().nullable().default(null),
+  circuit_breaker_target_id: z8.string().uuid().nullable().default(null),
+  created_at: z8.string().datetime({ offset: true }),
+  updated_at: z8.string().datetime({ offset: true })
+});
+var BoardWithRoleSchema = BoardSchema.extend({
+  role: BoardRoleSchema
+});
+var CreateBoardSchema = z8.object({
+  name: z8.string().min(1).max(100),
+  create_default_columns: z8.boolean().optional().default(false),
+  visibility: BoardVisibilitySchema.optional().default("private")
+});
+var IconSchema2 = z8.string().min(1).refine((val) => val.length <= 3 || val.includes("/") || val.includes("."), "Must be 1-3 character initials or a storage path");
+var UpdateBoardSchema = z8.object({
+  name: z8.string().min(1).max(100).optional(),
+  visibility: BoardVisibilitySchema.optional(),
+  icon: IconSchema2.nullable().optional(),
+  color: z8.enum(PALETTE_KEYS).nullable().optional(),
+  circuit_breaker_threshold: z8.number().int().positive().nullable().optional(),
+  circuit_breaker_target_id: z8.string().uuid().nullable().optional()
+});
+var TicketActionSchema = z8.enum(["move_to_backlog", "archive", "delete"]);
+var DeleteBoardBodySchema = z8.object({
+  ticket_action: TicketActionSchema.default("move_to_backlog")
+});
+var DeleteBoardPreviewSchema = z8.object({
+  tickets: z8.number().int().nonnegative(),
+  columns: z8.number().int().nonnegative(),
+  transition_rules: z8.number().int().nonnegative()
+});
+
+// ../types/dist/column.schema.js
+import { z as z9 } from "zod";
+var ColumnTypeSchema = z9.enum(["start", "in_progress", "done", "default", "evaluator"]);
+var ArchiveModeSchema = z9.enum(["off", "immediate", "delayed", "manual"]);
+var ColumnSchema = z9.object({
+  id: z9.string().uuid(),
+  board_id: z9.string().uuid(),
+  name: z9.string().min(1),
+  color: z9.string(),
+  position: z9.number().int(),
+  description: z9.string().nullable(),
+  column_type: ColumnTypeSchema,
+  wip_limit: z9.number().int().nullable(),
+  default_assignee_id: z9.string().uuid().nullable(),
+  archive_mode: ArchiveModeSchema.default("off"),
+  archive_delay_hours: z9.number().positive().nullable().default(null),
+  archive_overflow_limit: z9.number().int().positive().nullable().default(null),
+  prompt_document_id: z9.string().uuid().nullable().default(null),
+  goal: z9.string().nullable().default(null),
+  agent_config: z9.record(z9.string(), z9.unknown()).nullable().default(null),
+  created_at: z9.string().datetime({ offset: true }),
+  updated_at: z9.string().datetime({ offset: true })
+});
+var CreateColumnSchema = z9.object({
+  name: z9.string().min(1).max(100),
+  color: z9.string().optional()
+});
+var UpdateColumnSchema = z9.object({
+  name: z9.string().min(1).max(100).optional(),
+  color: z9.string().optional(),
+  description: z9.string().nullable().optional(),
+  column_type: ColumnTypeSchema.optional(),
+  wip_limit: z9.number().int().nullable().optional(),
+  default_assignee_id: z9.string().uuid().nullable().optional(),
+  archive_mode: ArchiveModeSchema.optional(),
+  archive_delay_hours: z9.number().positive().nullable().optional(),
+  archive_overflow_limit: z9.number().int().positive().nullable().optional(),
+  prompt_document_id: z9.string().uuid().nullable().optional(),
+  goal: z9.string().max(1e3).nullable().optional(),
+  agent_config: z9.record(z9.string(), z9.unknown()).nullable().optional()
+}).superRefine((data, ctx) => {
+  if (data.archive_mode === "delayed" && data.archive_delay_hours == null) {
+    ctx.addIssue({
+      code: z9.ZodIssueCode.custom,
+      message: "archive_delay_hours is required when archive_mode is delayed",
+      path: ["archive_delay_hours"]
+    });
+  }
+});
+var ReorderColumnsSchema = z9.array(z9.object({
+  id: z9.string().uuid(),
+  position: z9.number().int().nonnegative()
+}));
+var DeleteColumnBodySchema = z9.object({
+  ticket_action: TicketActionSchema.default("move_to_backlog")
+});
+var DeleteColumnPreviewSchema = z9.object({
+  tickets: z9.number().int().nonnegative(),
+  transition_rules_broken: z9.number().int().nonnegative(),
+  field_requirements_broken: z9.number().int().nonnegative()
+});
+
+// ../types/dist/ticket.schema.js
+import { z as z10 } from "zod";
+var TicketSchema = z10.object({
+  id: z10.string().uuid(),
+  board_id: z10.string().uuid().nullable(),
+  column_id: z10.string().uuid().nullable(),
+  project_id: z10.string().uuid(),
+  ticket_number: z10.number().int().positive(),
+  title: z10.string().min(1).max(500),
+  description: z10.string().max(1e4),
+  position: z10.number().int(),
+  assignee_id: z10.string().uuid().nullable(),
+  reporter_id: z10.string().uuid(),
+  custom_fields: z10.record(z10.string(), z10.unknown()).default({}),
+  created_at: z10.string().datetime({ offset: true }),
+  updated_at: z10.string().datetime({ offset: true }),
+  archived_at: z10.string().datetime({ offset: true }).nullable().default(null),
+  column_entered_at: z10.string().datetime({ offset: true }).nullable().default(null),
+  first_active_at: z10.string().datetime({ offset: true }).nullable().default(null),
+  done_at: z10.string().datetime({ offset: true }).nullable().default(null),
+  backward_transitions: z10.number().int().default(0),
+  parent_id: z10.string().uuid().nullable().default(null)
+});
+var TicketWithProfilesSchema = TicketSchema.extend({
+  assignee: UserProfileSchema.nullable(),
+  reporter: UserProfileSchema
+});
+var CreateTicketSchema = z10.object({
+  board_id: z10.string().uuid().nullable().optional().default(null),
+  column_id: z10.string().uuid().nullable().optional().default(null),
+  title: z10.string().min(1).max(500),
+  description: z10.string().max(1e4).optional(),
+  assignee_id: z10.string().uuid().nullable().optional(),
+  field_values: z10.record(z10.string(), z10.unknown()).optional(),
+  parent_id: z10.string().uuid().nullable().optional()
+});
+var UpdateTicketSchema = z10.object({
+  title: z10.string().min(1).max(500).optional(),
+  description: z10.string().max(1e4).optional(),
+  assignee_id: z10.string().uuid().nullable().optional(),
+  parent_id: z10.string().uuid().nullable().optional()
+});
+var MoveTicketSchema = z10.object({
+  column_id: z10.string().uuid().nullable(),
+  position: z10.number().int().nonnegative(),
+  handoff: z10.record(z10.string(), z10.unknown()).optional(),
+  force: z10.boolean().optional().default(false),
+  field_values: z10.record(z10.string(), z10.unknown()).optional().describe("Map of field name \u2192 value. Names are resolved to field IDs server-side.")
+});
+var MoveToBoardSchema = z10.object({
+  board_id: z10.string().uuid(),
+  column_id: z10.string().uuid()
+});
+var CreateBacklogTicketSchema = z10.object({
+  title: z10.string().min(1).max(500),
+  description: z10.string().max(1e4).optional(),
+  assignee_id: z10.string().uuid().nullable().optional()
+});
+var ReorderTicketsSchema = z10.array(z10.object({
+  id: z10.string().uuid(),
+  column_id: z10.string().uuid().nullable(),
+  position: z10.number().int().nonnegative()
+}));
+var DeleteTicketPreviewSchema = z10.object({
+  comments: z10.number().int().nonnegative(),
+  attachments: z10.number().int().nonnegative()
+});
+
+// ../types/dist/comment.schema.js
+import { z as z11 } from "zod";
+var CommentSchema = z11.object({
+  id: z11.string().uuid(),
+  ticket_id: z11.string().uuid(),
+  author_id: z11.string().uuid(),
+  body: z11.string().min(1),
+  created_at: z11.string().datetime({ offset: true }),
+  updated_at: z11.string().datetime({ offset: true }),
+  pinned: z11.boolean().default(false)
+});
+var CommentWithAuthorSchema = CommentSchema.extend({
+  author: UserProfileSchema
+});
+var CreateCommentSchema = z11.object({
+  body: z11.string().min(1).max(1e4)
+});
+var UpdateCommentSchema = z11.object({
+  body: z11.string().min(1).max(1e4).optional(),
+  pinned: z11.boolean().optional()
+});
+
+// ../types/dist/jobs.schema.js
+import { z as z12 } from "zod";
+var WelcomeEmailJobDataSchema = z12.object({
+  userId: z12.string().uuid(),
+  email: z12.string().email(),
+  displayName: z12.string()
+});
+var InvitationEmailJobDataSchema = z12.object({
+  email: z12.string().email(),
+  projectName: z12.string(),
+  token: z12.string(),
+  role: z12.string(),
+  invitedBy: z12.string().uuid()
+});
+
+// ../types/dist/upload.schema.js
+import { z as z13 } from "zod";
+var UploadResultSchema = z13.object({
+  path: z13.string(),
+  url: z13.string().url().nullable()
+});
+
+// ../types/dist/ticket-attachment.schema.js
+import { z as z14 } from "zod";
+var TicketAttachmentSchema = z14.object({
+  id: z14.string().uuid(),
+  ticket_id: z14.string().uuid(),
+  uploader_id: z14.string().uuid(),
+  storage_path: z14.string().min(1),
+  file_name: z14.string().min(1),
+  mime_type: z14.string().min(1),
+  file_size: z14.number().int().positive(),
+  created_at: z14.string().datetime({ offset: true })
+});
+var TicketAttachmentWithUrlSchema = TicketAttachmentSchema.extend({
+  url: z14.string()
+});
+var CreateTicketAttachmentSchema = z14.object({
+  storage_path: z14.string().min(1),
+  file_name: z14.string().min(1),
+  mime_type: z14.string().min(1),
+  file_size: z14.number().int().positive()
+});
+
+// ../types/dist/board-ws.schema.js
+import { z as z22 } from "zod";
+
+// ../types/dist/field-definition.schema.js
+import { z as z15 } from "zod";
+var FieldTypeSchema = z15.enum([
+  "short_text",
+  "long_text",
+  "rich_text",
+  "number",
+  "date",
+  "single_select",
+  "multi_select",
+  "checkbox",
+  "user",
+  "ticket_link",
+  "document_link",
+  "github_pr"
+]);
+var CreateFieldTypeSchema = z15.enum([
+  "short_text",
+  "long_text",
+  "rich_text",
+  "number",
+  "date",
+  "single_select",
+  "multi_select",
+  "checkbox",
+  "user",
+  "document_link",
+  "github_pr"
+]);
+var SelectOptionSchema = z15.object({
+  id: z15.string().uuid(),
+  label: z15.string().min(1).max(100),
+  color: z15.string()
+});
+var FieldConfigSchema = z15.object({
+  placeholder: z15.string().optional(),
+  max_length: z15.number().int().positive().optional(),
+  regex: z15.string().optional(),
+  min: z15.number().optional(),
+  max: z15.number().optional(),
+  decimals: z15.number().int().min(0).optional(),
+  unit: z15.string().optional(),
+  allow_past: z15.boolean().optional(),
+  allow_time: z15.boolean().optional(),
+  options: z15.array(SelectOptionSchema).optional(),
+  max_selections: z15.number().int().positive().optional(),
+  default_checked: z15.boolean().optional(),
+  scope: z15.enum(["board", "project"]).optional(),
+  show_checks: z15.boolean().optional(),
+  show_reviews: z15.boolean().optional()
+}).default({});
+var FieldDefinitionSchema = z15.object({
+  id: z15.string().uuid(),
+  project_id: z15.string().uuid(),
+  name: z15.string().min(1).max(100),
+  type: FieldTypeSchema,
+  config: FieldConfigSchema,
+  position: z15.number().int(),
+  created_at: z15.string().datetime({ offset: true }),
+  updated_at: z15.string().datetime({ offset: true })
+});
+var CreateFieldDefinitionSchema = z15.object({
+  name: z15.string().min(1).max(100),
+  type: FieldTypeSchema,
+  config: FieldConfigSchema.optional()
+});
+var UpdateFieldDefinitionSchema = z15.object({
+  name: z15.string().min(1).max(100).optional(),
+  config: FieldConfigSchema.optional(),
+  position: z15.number().int().optional()
+});
+var ReorderFieldDefinitionsSchema = z15.object({
+  items: z15.array(z15.object({
+    id: z15.string().uuid(),
+    position: z15.number().int()
+  }))
+});
+var DeleteFieldDefinitionPreviewSchema = z15.object({
+  tickets_affected: z15.number().int().nonnegative(),
+  field_values: z15.number().int().nonnegative(),
+  board_overrides: z15.number().int().nonnegative()
+});
+
+// ../types/dist/field-override.schema.js
+import { z as z16 } from "zod";
+var BoardFieldOverrideSchema = z16.object({
+  id: z16.string().uuid(),
+  board_id: z16.string().uuid(),
+  field_id: z16.string().uuid(),
+  is_enabled: z16.boolean(),
+  is_required: z16.boolean(),
+  show_on_card: z16.boolean(),
+  position: z16.number().int().nullable(),
+  default_value: z16.unknown().nullable(),
+  extra_options: z16.array(SelectOptionSchema).nullable(),
+  created_at: z16.string().datetime({ offset: true }),
+  updated_at: z16.string().datetime({ offset: true })
+});
+var UpsertFieldOverrideSchema = z16.object({
+  is_enabled: z16.boolean().optional(),
+  is_required: z16.boolean().optional(),
+  show_on_card: z16.boolean().optional(),
+  position: z16.number().int().nullable().optional(),
+  default_value: z16.unknown().nullable().optional(),
+  extra_options: z16.array(SelectOptionSchema).nullable().optional()
+});
+var MergedFieldSchema = FieldDefinitionSchema.extend({
+  is_enabled: z16.boolean().default(true),
+  is_required: z16.boolean().default(false),
+  show_on_card: z16.boolean().default(false),
+  effective_position: z16.number().int(),
+  default_value: z16.unknown().nullable().default(null),
+  extra_options: z16.array(SelectOptionSchema).default([]),
+  all_options: z16.array(SelectOptionSchema).default([])
+});
+
+// ../types/dist/transition-rule.schema.js
+import { z as z17 } from "zod";
+var TransitionRuleStatusSchema = z17.enum(["active", "broken"]);
+var TransitionRuleSchema = z17.object({
+  id: z17.string().uuid(),
+  board_id: z17.string().uuid(),
+  from_column_id: z17.string().uuid().nullable(),
+  to_column_id: z17.string().uuid().nullable(),
+  from_tombstone_id: z17.string().uuid().nullable(),
+  to_tombstone_id: z17.string().uuid().nullable(),
+  status: TransitionRuleStatusSchema,
+  instruction: z17.string().nullable(),
+  created_at: z17.string().datetime({ offset: true }),
+  updated_at: z17.string().datetime({ offset: true })
+});
+var TransitionRuleWithTombstoneSchema = TransitionRuleSchema.extend({
+  from_tombstone_name: z17.string().nullable().default(null),
+  to_tombstone_name: z17.string().nullable().default(null)
+});
+var BulkUpsertTransitionRulesSchema = z17.object({
+  rules: z17.array(z17.object({
+    from_column_id: z17.string().uuid().nullable(),
+    to_column_id: z17.string().uuid(),
+    instruction: z17.string().nullable().optional()
+  }))
+});
+
+// ../types/dist/signal.schema.js
+import { z as z18 } from "zod";
+var SignalScopeTypeSchema = z18.enum(["project", "board", "column", "ticket"]);
+var SignalSourceSchema = z18.enum(["human", "agent"]);
+var SignalSchema = z18.object({
+  id: z18.string().uuid(),
+  project_id: z18.string().uuid(),
+  scope_type: SignalScopeTypeSchema,
+  scope_id: z18.string().uuid(),
+  content: z18.string().min(1),
+  source: SignalSourceSchema,
+  created_by: z18.string().uuid().nullable(),
+  session_id: z18.string().uuid().nullable(),
+  iteration: z18.number().int().nullable(),
+  created_at: z18.string().datetime({ offset: true }),
+  updated_at: z18.string().datetime({ offset: true })
+});
+var CreateSignalSchema = z18.object({
+  scopeType: SignalScopeTypeSchema,
+  scopeId: z18.string().uuid(),
+  content: z18.string().min(1).max(5e3)
+});
+var UpdateSignalSchema = z18.object({
+  content: z18.string().min(1).max(5e3)
+});
+var PromoteSignalSchema = z18.object({
+  newScopeType: SignalScopeTypeSchema,
+  newScopeId: z18.string().uuid()
+});
+
+// ../types/dist/pipeline-session.schema.js
+import { z as z19 } from "zod";
+var InvocationTypeSchema = z19.enum(["heavy", "light", "advisor", "stuck_detection", "orchestrator", "replanner"]);
+var ExitReasonSchema = z19.enum(["moved", "stalled", "error", "max_iterations", "stopped", "deleted"]);
+var PipelineSessionSchema = z19.object({
+  id: z19.string().uuid(),
+  project_id: z19.string().uuid(),
+  board_id: z19.string().uuid(),
+  ticket_id: z19.string().uuid().nullable(),
+  column_id: z19.string().uuid().nullable(),
+  run_id: z19.string().min(1).max(128),
+  session_id: z19.string().min(1).max(128),
+  model: z19.string().min(1).max(100),
+  invocation_type: InvocationTypeSchema,
+  iteration: z19.number().int().nullable(),
+  tokens_in: z19.number().int().nonnegative(),
+  tokens_out: z19.number().int().nonnegative(),
+  tool_call_count: z19.number().int().nonnegative(),
+  duration_ms: z19.number().int().nonnegative(),
+  exit_reason: ExitReasonSchema.nullable(),
+  started_at: z19.string().datetime({ offset: true }),
+  ended_at: z19.string().datetime({ offset: true }).nullable(),
+  created_at: z19.string().datetime({ offset: true }),
+  updated_at: z19.string().datetime({ offset: true }).nullable()
+});
+var CreatePipelineSessionSchema = z19.object({
+  project_id: z19.string().uuid(),
+  board_id: z19.string().uuid(),
+  ticket_id: z19.string().uuid().nullable(),
+  column_id: z19.string().uuid().nullable(),
+  run_id: z19.string().min(1).max(128),
+  session_id: z19.string().min(1).max(128),
+  model: z19.string().min(1).max(100),
+  invocation_type: InvocationTypeSchema,
+  iteration: z19.number().int().nullable().optional(),
+  started_at: z19.string().datetime({ offset: true }).optional()
+});
+var UpdatePipelineSessionSchema = z19.object({
+  tokens_in: z19.number().int().nonnegative(),
+  tokens_out: z19.number().int().nonnegative(),
+  tool_call_count: z19.number().int().nonnegative(),
+  duration_ms: z19.number().int().nonnegative(),
+  exit_reason: ExitReasonSchema.nullable(),
+  ended_at: z19.string().datetime({ offset: true })
+});
+var PipelineSessionQuerySchema = z19.object({
+  ticketId: z19.string().uuid().optional(),
+  boardId: z19.string().uuid().optional(),
+  sessionId: z19.string().optional(),
+  limit: z19.coerce.number().int().min(1).max(100).optional().default(50),
+  cursor: z19.string().optional()
+});
+
+// ../types/dist/firing-constraint.schema.js
+import { z as z20 } from "zod";
+var FiringConstraintSubjectTypeSchema = z20.enum([
+  "column.ticket_count",
+  "column.active_loops",
+  "column.wip_remaining",
+  "column.last_fired_at",
+  "board.total_active_loops",
+  "board.circuit_breaker_count",
+  "backlog.ticket_count",
+  "ticket.field_value",
+  "time.hour"
+]);
+var FiringConstraintOperatorSchema = z20.enum(["lt", "lte", "gt", "gte", "eq", "neq"]);
+var FiringConstraintScopeSchema = z20.enum(["column", "ticket"]);
+var FiringConstraintSchema = z20.object({
+  id: z20.string().uuid(),
+  project_id: z20.string().uuid(),
+  board_id: z20.string().uuid(),
+  column_id: z20.string().uuid().nullable(),
+  name: z20.string().min(1).max(200),
+  description: z20.string().nullable(),
+  enabled: z20.boolean(),
+  subject_type: FiringConstraintSubjectTypeSchema,
+  subject_ref: z20.string().nullable(),
+  subject_param: z20.string().nullable(),
+  operator: FiringConstraintOperatorSchema,
+  value: z20.union([z20.number(), z20.string(), z20.boolean()]),
+  scope: FiringConstraintScopeSchema,
+  notify: z20.boolean(),
+  position: z20.number().int(),
+  fail_open: z20.boolean(),
+  system: z20.boolean(),
+  created_at: z20.string().datetime({ offset: true }),
+  updated_at: z20.string().datetime({ offset: true })
+});
+var CreateFiringConstraintSchema = z20.object({
+  column_id: z20.string().uuid().nullable().optional(),
+  name: z20.string().min(1).max(200),
+  description: z20.string().nullable().optional(),
+  subject_type: FiringConstraintSubjectTypeSchema,
+  subject_ref: z20.string().nullable().optional(),
+  subject_param: z20.string().nullable().optional(),
+  operator: FiringConstraintOperatorSchema,
+  value: z20.union([z20.number(), z20.string(), z20.boolean()]),
+  scope: FiringConstraintScopeSchema.default("column"),
+  notify: z20.boolean().default(false),
+  enabled: z20.boolean().default(true),
+  fail_open: z20.boolean().default(false),
+  system: z20.boolean().default(false)
+});
+var UpdateFiringConstraintSchema = z20.object({
+  column_id: z20.string().uuid().nullable().optional(),
+  name: z20.string().min(1).max(200).optional(),
+  description: z20.string().nullable().optional(),
+  enabled: z20.boolean().optional(),
+  subject_type: FiringConstraintSubjectTypeSchema.optional(),
+  subject_ref: z20.string().nullable().optional(),
+  subject_param: z20.string().nullable().optional(),
+  operator: FiringConstraintOperatorSchema.optional(),
+  value: z20.union([z20.number(), z20.string(), z20.boolean()]).optional(),
+  scope: FiringConstraintScopeSchema.optional(),
+  notify: z20.boolean().optional(),
+  position: z20.number().int().optional(),
+  fail_open: z20.boolean().optional()
+});
+var EvaluateFiringConstraintResultSchema = z20.object({
+  constraint_id: z20.string().uuid(),
+  name: z20.string(),
+  column_id: z20.string().uuid().nullable(),
+  passed: z20.boolean(),
+  resolved_value: z20.union([z20.number(), z20.string(), z20.boolean()]).nullable(),
+  threshold: z20.object({
+    operator: z20.string(),
+    value: z20.union([z20.number(), z20.string(), z20.boolean()])
+  }),
+  error: z20.string().optional()
+});
+var EvaluateFiringConstraintsResponseSchema = z20.object({
+  board_id: z20.string().uuid(),
+  results: z20.array(EvaluateFiringConstraintResultSchema),
+  summary: z20.object({
+    total: z20.number().int(),
+    passed: z20.number().int(),
+    failed: z20.number().int(),
+    errors: z20.number().int()
+  })
+});
+
+// ../types/dist/pipeline-event.schema.js
+import { z as z21 } from "zod";
+var PipelineEventLayerSchema = z21.enum([
+  "gate",
+  "advisor",
+  "evaluator",
+  "constraint",
+  "cost",
+  "session",
+  "replanner"
+]);
+var PipelineEventSeveritySchema = z21.enum(["info", "warning", "failure"]);
+var PipelineEventSchema = z21.object({
+  id: z21.string().uuid(),
+  project_id: z21.string().uuid(),
+  board_id: z21.string().uuid(),
+  ticket_id: z21.string().uuid().nullable(),
+  column_id: z21.string().uuid().nullable(),
+  run_id: z21.string().nullable(),
+  session_id: z21.string().nullable(),
+  layer: PipelineEventLayerSchema,
+  event_type: z21.string().min(1).max(100),
+  severity: PipelineEventSeveritySchema,
+  summary: z21.string().min(1).max(1e3),
+  detail: z21.record(z21.unknown()).nullable(),
+  iteration: z21.number().int().nullable(),
+  created_at: z21.string().datetime({ offset: true })
+});
+var CreatePipelineEventSchema = z21.object({
+  board_id: z21.string().uuid(),
+  ticket_id: z21.string().uuid().nullable().optional(),
+  column_id: z21.string().uuid().nullable().optional(),
+  run_id: z21.string().nullable().optional(),
+  session_id: z21.string().nullable().optional(),
+  layer: PipelineEventLayerSchema,
+  event_type: z21.string().min(1).max(100),
+  severity: PipelineEventSeveritySchema,
+  summary: z21.string().min(1).max(1e3),
+  detail: z21.record(z21.unknown()).nullable().optional(),
+  iteration: z21.number().int().nullable().optional()
+});
+var CreatePipelineEventBatchSchema = z21.object({
+  events: z21.array(CreatePipelineEventSchema).min(1).max(100)
+});
+
+// ../types/dist/board-ws.schema.js
+var WsActorSchema = z22.object({
+  id: z22.string().uuid(),
+  displayName: z22.string()
+}).nullable();
+var WsBoardSubscribeSchema = z22.object({
+  type: z22.literal("board:subscribe"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    projectId: z22.string().uuid()
+  })
+});
+var WsBoardUnsubscribeSchema = z22.object({
+  type: z22.literal("board:unsubscribe"),
+  payload: z22.object({
+    boardId: z22.string().uuid()
+  })
+});
+var pipelineIdString = z22.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
+var WsPipelineStreamClientSchema = z22.object({
+  type: z22.literal("pipeline:stream"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid().nullable(),
+    columnId: z22.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    event: z22.record(z22.unknown())
+  })
+});
+var WsPipelineSessionStartClientSchema = z22.object({
+  type: z22.literal("pipeline:session-start"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid().nullable(),
+    columnId: z22.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    model: z22.string(),
+    invocationType: InvocationTypeSchema,
+    iteration: z22.number().int().nullable()
+  })
+});
+var WsPipelineSessionEndClientSchema = z22.object({
+  type: z22.literal("pipeline:session-end"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    runId: pipelineIdString,
+    exitReason: ExitReasonSchema.nullable(),
+    tokensIn: z22.number().int().nonnegative(),
+    tokensOut: z22.number().int().nonnegative(),
+    toolCallCount: z22.number().int().nonnegative(),
+    durationMs: z22.number().int().nonnegative()
+  })
+});
+var WsPipelineStoppedClientSchema = z22.object({
+  type: z22.literal("pipeline:stopped"),
+  payload: z22.object({
+    boardId: z22.string().uuid()
+  })
+});
+var WsBoardClientEvents = [
+  WsBoardSubscribeSchema,
+  WsBoardUnsubscribeSchema,
+  WsPipelineStreamClientSchema,
+  WsPipelineSessionStartClientSchema,
+  WsPipelineSessionEndClientSchema,
+  WsPipelineStoppedClientSchema
+];
+var WsBoardUpdatedSchema = z22.object({
+  type: z22.literal("board:updated"),
+  payload: z22.object({
+    board: BoardWithRoleSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardDeletedSchema = z22.object({
+  type: z22.literal("board:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBoardSubscribedSchema = z22.object({
+  type: z22.literal("board:subscribed"),
+  payload: z22.object({
+    boardId: z22.string().uuid()
+  })
+});
+var WsBoardUnsubscribedSchema = z22.object({
+  type: z22.literal("board:unsubscribed"),
+  payload: z22.object({
+    boardId: z22.string().uuid()
+  })
+});
+var WsBoardAccessRevokedSchema = z22.object({
+  type: z22.literal("board:access-revoked"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    reason: z22.string()
+  })
+});
+var WsColumnCreatedSchema = z22.object({
+  type: z22.literal("column:created"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    column: ColumnSchema,
+    actor: WsActorSchema
+  })
+});
+var WsColumnUpdatedSchema = z22.object({
+  type: z22.literal("column:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    column: ColumnSchema,
+    actor: WsActorSchema
+  })
+});
+var WsColumnDeletedSchema = z22.object({
+  type: z22.literal("column:deleted"),
+  payload: z22.object({
+    columnId: z22.string().uuid(),
+    ticketAction: z22.enum(["delete", "archive", "move_to_backlog"]),
+    ticketIds: z22.array(z22.string().uuid()),
+    actor: WsActorSchema
+  })
+});
+var WsColumnReorderedSchema = z22.object({
+  type: z22.literal("column:reordered"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    columns: z22.array(z22.object({ id: z22.string().uuid(), position: z22.number().int() })),
+    actor: WsActorSchema
+  })
+});
+var WsTicketCreatedSchema = z22.object({
+  type: z22.literal("ticket:created"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    columnId: z22.string().uuid().nullable(),
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketUpdatedSchema = z22.object({
+  type: z22.literal("ticket:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketDeletedSchema = z22.object({
+  type: z22.literal("ticket:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsTicketMovedSchema = z22.object({
+  type: z22.literal("ticket:moved"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticket: TicketWithProfilesSchema,
+    fromColumnId: z22.string().uuid().nullable(),
+    actor: WsActorSchema
+  })
+});
+var WsTicketReorderedSchema = z22.object({
+  type: z22.literal("ticket:reordered"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    tickets: z22.array(z22.object({
+      id: z22.string().uuid(),
+      columnId: z22.string().uuid().nullable(),
+      position: z22.number().int()
+    })),
+    actor: WsActorSchema
+  })
+});
+var WsTicketArchivedSchema = z22.object({
+  type: z22.literal("ticket:archived"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    archivedAt: z22.string().datetime({ offset: true }),
+    actor: WsActorSchema
+  })
+});
+var WsTicketUnarchivedSchema = z22.object({
+  type: z22.literal("ticket:unarchived"),
+  payload: z22.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketBulkArchivedSchema = z22.object({
+  type: z22.literal("ticket:bulk-archived"),
+  payload: z22.object({
+    columnId: z22.string().uuid(),
+    ticketIds: z22.array(z22.string().uuid()),
+    actor: WsActorSchema
+  })
+});
+var WsCommentCreatedSchema = z22.object({
+  type: z22.literal("comment:created"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    comment: CommentWithAuthorSchema,
+    actor: WsActorSchema
+  })
+});
+var WsCommentUpdatedSchema = z22.object({
+  type: z22.literal("comment:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    comment: CommentWithAuthorSchema,
+    actor: WsActorSchema
+  })
+});
+var WsCommentDeletedSchema = z22.object({
+  type: z22.literal("comment:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    commentId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsAttachmentCreatedSchema = z22.object({
+  type: z22.literal("attachment:created"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    attachment: TicketAttachmentWithUrlSchema,
+    actor: WsActorSchema
+  })
+});
+var WsAttachmentDeletedSchema = z22.object({
+  type: z22.literal("attachment:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid(),
+    attachmentId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsFieldValueUpdatedSchema = z22.object({
+  type: z22.literal("field-value:updated"),
+  payload: z22.object({
+    ticketId: z22.string().uuid(),
+    fieldId: z22.string().uuid(),
+    value: z22.unknown(),
+    customFields: z22.record(z22.string(), z22.unknown()),
+    actor: WsActorSchema
+  })
+});
+var WsFieldValueRemovedSchema = z22.object({
+  type: z22.literal("field-value:removed"),
+  payload: z22.object({
+    ticketId: z22.string().uuid(),
+    fieldId: z22.string().uuid(),
+    customFields: z22.record(z22.string(), z22.unknown()),
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionCreatedSchema = z22.object({
+  type: z22.literal("field-definition:created"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    field: FieldDefinitionSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionUpdatedSchema = z22.object({
+  type: z22.literal("field-definition:updated"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    field: FieldDefinitionSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionDeletedSchema = z22.object({
+  type: z22.literal("field-definition:deleted"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    fieldId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionReorderedSchema = z22.object({
+  type: z22.literal("field-definition:reordered"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    fields: z22.array(z22.object({ id: z22.string().uuid(), position: z22.number().int() })),
+    actor: WsActorSchema
+  })
+});
+var WsFieldOverrideUpdatedSchema = z22.object({
+  type: z22.literal("field-override:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    fieldOverride: BoardFieldOverrideSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldOverrideDeletedSchema = z22.object({
+  type: z22.literal("field-override:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    fieldId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsTransitionRulesUpdatedSchema = z22.object({
+  type: z22.literal("transition-rules:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    rules: z22.array(TransitionRuleSchema),
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberAddedSchema = z22.object({
+  type: z22.literal("board-member:added"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    member: BoardMemberWithProfileSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberUpdatedSchema = z22.object({
+  type: z22.literal("board-member:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    member: BoardMemberWithProfileSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberRemovedSchema = z22.object({
+  type: z22.literal("board-member:removed"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    userId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketAddedSchema = z22.object({
+  type: z22.literal("backlog:ticket-added"),
+  payload: z22.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketRemovedSchema = z22.object({
+  type: z22.literal("backlog:ticket-removed"),
+  payload: z22.object({
+    ticketId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketUpdatedSchema = z22.object({
+  type: z22.literal("backlog:ticket-updated"),
+  payload: z22.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketArchivedSchema = z22.object({
+  type: z22.literal("backlog:ticket-archived"),
+  payload: z22.object({
+    ticketId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketUnarchivedSchema = z22.object({
+  type: z22.literal("backlog:ticket-unarchived"),
+  payload: z22.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketsAddedSchema = z22.object({
+  type: z22.literal("backlog:tickets-added"),
+  payload: z22.object({
+    ticketIds: z22.array(z22.string().uuid()),
+    projectId: z22.string().uuid()
+  })
+});
+var WsBoardlistCreatedSchema = z22.object({
+  type: z22.literal("boardlist:created"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    board: BoardSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardlistUpdatedSchema = z22.object({
+  type: z22.literal("boardlist:updated"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    board: BoardSchema.partial().extend({ id: z22.string().uuid() }),
+    actor: WsActorSchema
+  })
+});
+var WsBoardlistDeletedSchema = z22.object({
+  type: z22.literal("boardlist:deleted"),
+  payload: z22.object({
+    projectId: z22.string().uuid(),
+    boardId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsSignalCreatedSchema = z22.object({
+  type: z22.literal("signal:created"),
+  payload: z22.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsSignalUpdatedSchema = z22.object({
+  type: z22.literal("signal:updated"),
+  payload: z22.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsSignalDeletedSchema = z22.object({
+  type: z22.literal("signal:deleted"),
+  payload: z22.object({
+    signalId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsSignalPromotedSchema = z22.object({
+  type: z22.literal("signal:promoted"),
+  payload: z22.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintCreatedSchema = z22.object({
+  type: z22.literal("firing_constraint:created"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    constraint: FiringConstraintSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintUpdatedSchema = z22.object({
+  type: z22.literal("firing_constraint:updated"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    constraint: FiringConstraintSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintDeletedSchema = z22.object({
+  type: z22.literal("firing_constraint:deleted"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    constraintId: z22.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsPipelineStreamSchema = z22.object({
+  type: z22.literal("pipeline:stream"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid().nullable(),
+    columnId: z22.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    event: z22.record(z22.unknown())
+  })
+});
+var WsPipelineSessionStartSchema = z22.object({
+  type: z22.literal("pipeline:session-start"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    ticketId: z22.string().uuid().nullable(),
+    columnId: z22.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    model: z22.string(),
+    invocationType: InvocationTypeSchema,
+    iteration: z22.number().int().nullable()
+  })
+});
+var WsPipelineSessionEndSchema = z22.object({
+  type: z22.literal("pipeline:session-end"),
+  payload: z22.object({
+    boardId: z22.string().uuid(),
+    runId: pipelineIdString,
+    exitReason: ExitReasonSchema.nullable(),
+    tokensIn: z22.number().int().nonnegative(),
+    tokensOut: z22.number().int().nonnegative(),
+    toolCallCount: z22.number().int().nonnegative(),
+    durationMs: z22.number().int().nonnegative()
+  })
+});
+var WsPipelineStoppedSchema = z22.object({
+  type: z22.literal("pipeline:stopped"),
+  payload: z22.object({
+    boardId: z22.string().uuid()
+  })
+});
+var WsPipelineEventSchema = z22.object({
+  type: z22.literal("pipeline:event"),
+  payload: PipelineEventSchema
+});
+var WsBoardServerEvents = [
+  WsBoardUpdatedSchema,
+  WsBoardDeletedSchema,
+  WsBoardSubscribedSchema,
+  WsBoardUnsubscribedSchema,
+  WsBoardAccessRevokedSchema,
+  WsColumnCreatedSchema,
+  WsColumnUpdatedSchema,
+  WsColumnDeletedSchema,
+  WsColumnReorderedSchema,
+  WsTicketCreatedSchema,
+  WsTicketUpdatedSchema,
+  WsTicketDeletedSchema,
+  WsTicketMovedSchema,
+  WsTicketReorderedSchema,
+  WsTicketArchivedSchema,
+  WsTicketUnarchivedSchema,
+  WsTicketBulkArchivedSchema,
+  WsCommentCreatedSchema,
+  WsCommentUpdatedSchema,
+  WsCommentDeletedSchema,
+  WsAttachmentCreatedSchema,
+  WsAttachmentDeletedSchema,
+  WsFieldValueUpdatedSchema,
+  WsFieldValueRemovedSchema,
+  WsFieldDefinitionCreatedSchema,
+  WsFieldDefinitionUpdatedSchema,
+  WsFieldDefinitionDeletedSchema,
+  WsFieldDefinitionReorderedSchema,
+  WsFieldOverrideUpdatedSchema,
+  WsFieldOverrideDeletedSchema,
+  WsTransitionRulesUpdatedSchema,
+  WsBoardMemberAddedSchema,
+  WsBoardMemberUpdatedSchema,
+  WsBoardMemberRemovedSchema,
+  WsBacklogTicketAddedSchema,
+  WsBacklogTicketRemovedSchema,
+  WsBacklogTicketUpdatedSchema,
+  WsBacklogTicketArchivedSchema,
+  WsBacklogTicketUnarchivedSchema,
+  WsBacklogTicketsAddedSchema,
+  WsBoardlistCreatedSchema,
+  WsBoardlistUpdatedSchema,
+  WsBoardlistDeletedSchema,
+  WsSignalCreatedSchema,
+  WsSignalUpdatedSchema,
+  WsSignalDeletedSchema,
+  WsSignalPromotedSchema,
+  WsFiringConstraintCreatedSchema,
+  WsFiringConstraintUpdatedSchema,
+  WsFiringConstraintDeletedSchema,
+  WsPipelineStreamSchema,
+  WsPipelineSessionStartSchema,
+  WsPipelineSessionEndSchema,
+  WsPipelineStoppedSchema,
+  WsPipelineEventSchema
+];
+
+// ../types/dist/chat.schema.js
+import { z as z24 } from "zod";
+
+// ../types/dist/call.schema.js
+import { z as z23 } from "zod";
+var CallTypeSchema = z23.enum(["audio", "screen_share"]);
+var CallStatusSchema = z23.enum(["ringing", "active", "ended", "missed"]);
+var UserStatusSchema = z23.enum(["online", "away", "in_call", "dnd", "offline"]);
+var CallSessionSchema = z23.object({
+  id: z23.string().uuid(),
+  project_id: z23.string().uuid(),
+  conversation_id: z23.string().uuid().nullable(),
+  status: CallStatusSchema,
+  created_by: z23.string().uuid(),
+  livekit_room_name: z23.string(),
+  started_at: z23.string().datetime({ offset: true }).nullable(),
+  ended_at: z23.string().datetime({ offset: true }).nullable(),
+  created_at: z23.string().datetime({ offset: true })
+});
+var CallParticipantSchema = z23.object({
+  id: z23.string().uuid(),
+  session_id: z23.string().uuid(),
+  user_id: z23.string().uuid(),
+  joined_at: z23.string().datetime({ offset: true }).nullable(),
+  left_at: z23.string().datetime({ offset: true }).nullable()
+});
+var CallParticipantWithProfileSchema = CallParticipantSchema.extend({
+  user: UserProfileSchema
+});
+var CallSessionWithParticipantsSchema = CallSessionSchema.extend({
+  participants: z23.array(CallParticipantWithProfileSchema),
+  creator: UserProfileSchema
+});
+var StartCallSchema = z23.object({
+  conversationId: z23.string().uuid().optional(),
+  participantIds: z23.array(z23.string().uuid()).min(1).max(4)
+});
+var JoinCallSchema = z23.object({
+  sessionId: z23.string().uuid()
+});
+var CallTokenResponseSchema = z23.object({
+  token: z23.string(),
+  wsUrl: z23.string(),
+  roomName: z23.string(),
+  sessionId: z23.string().uuid()
+});
+var WsCallStartSchema = z23.object({
+  type: z23.literal("call:start"),
+  payload: StartCallSchema.extend({
+    projectId: z23.string().uuid()
+  })
+});
+var WsCallAcceptSchema = z23.object({
+  type: z23.literal("call:accept"),
+  payload: z23.object({ sessionId: z23.string().uuid() })
+});
+var WsCallDeclineSchema = z23.object({
+  type: z23.literal("call:decline"),
+  payload: z23.object({ sessionId: z23.string().uuid() })
+});
+var WsCallLeaveSchema = z23.object({
+  type: z23.literal("call:leave"),
+  payload: z23.object({ sessionId: z23.string().uuid() })
+});
+var WsCallEndSchema = z23.object({
+  type: z23.literal("call:end"),
+  payload: z23.object({ sessionId: z23.string().uuid() })
+});
+var WsStatusSetSchema = z23.object({
+  type: z23.literal("status:set"),
+  payload: z23.object({ status: z23.enum(["online", "away", "dnd"]) })
+});
+var WsServerCallRingSchema = z23.object({
+  type: z23.literal("call:ring"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    projectId: z23.string().uuid(),
+    conversationId: z23.string().uuid().nullable(),
+    callerId: z23.string().uuid(),
+    callerName: z23.string(),
+    participantIds: z23.array(z23.string().uuid())
+  })
+});
+var WsServerCallStartedSchema = z23.object({
+  type: z23.literal("call:started"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    projectId: z23.string().uuid(),
+    conversationId: z23.string().uuid().nullable()
+  })
+});
+var WsServerCallParticipantJoinedSchema = z23.object({
+  type: z23.literal("call:participant-joined"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    userId: z23.string().uuid(),
+    displayName: z23.string()
+  })
+});
+var WsServerCallParticipantLeftSchema = z23.object({
+  type: z23.literal("call:participant-left"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    userId: z23.string().uuid()
+  })
+});
+var WsServerCallEndedSchema = z23.object({
+  type: z23.literal("call:ended"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    projectId: z23.string().uuid()
+  })
+});
+var WsServerCallDeclinedSchema = z23.object({
+  type: z23.literal("call:declined"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    userId: z23.string().uuid()
+  })
+});
+var WsServerCallMissedSchema = z23.object({
+  type: z23.literal("call:missed"),
+  payload: z23.object({
+    sessionId: z23.string().uuid(),
+    projectId: z23.string().uuid(),
+    callerId: z23.string().uuid(),
+    callerName: z23.string()
+  })
+});
+var WsServerStatusUpdateSchema = z23.object({
+  type: z23.literal("status:update"),
+  payload: z23.object({
+    userId: z23.string().uuid(),
+    status: UserStatusSchema
+  })
+});
+
+// ../types/dist/chat.schema.js
+var ChatConversationTypeSchema = z24.enum(["group", "direct"]);
+var PushPlatformSchema = z24.enum(["web", "ios", "android"]);
+var ChatConversationSchema = z24.object({
+  id: z24.string().uuid(),
+  project_id: z24.string().uuid(),
+  type: ChatConversationTypeSchema,
+  name: z24.string().nullable(),
+  created_by: z24.string().uuid(),
+  created_at: z24.string().datetime({ offset: true }),
+  updated_at: z24.string().datetime({ offset: true })
+});
+var MessagePreviewSchema = z24.object({
+  id: z24.string().uuid(),
+  body: z24.string(),
+  sender_id: z24.string().uuid(),
+  created_at: z24.string().datetime({ offset: true })
+});
+var ChatConversationWithPreviewSchema = ChatConversationSchema.extend({
+  lastMessage: MessagePreviewSchema.nullable(),
+  unreadCount: z24.number().int().min(0),
+  participants: z24.array(UserProfileSchema),
+  projectName: z24.string(),
+  muted_at: z24.string().datetime({ offset: true }).nullable(),
+  pinned_at: z24.string().datetime({ offset: true }).nullable(),
+  enter_sends_override: z24.boolean().nullable().default(null)
+});
+var ChatParticipantSchema = z24.object({
+  id: z24.string().uuid(),
+  conversation_id: z24.string().uuid(),
+  user_id: z24.string().uuid(),
+  joined_at: z24.string().datetime({ offset: true }),
+  left_at: z24.string().datetime({ offset: true }).nullable(),
+  deleted_at: z24.string().datetime({ offset: true }).nullable(),
+  muted_at: z24.string().datetime({ offset: true }).nullable(),
+  pinned_at: z24.string().datetime({ offset: true }).nullable(),
+  enter_sends_override: z24.boolean().nullable().default(null)
+});
+var ChatParticipantWithProfileSchema = ChatParticipantSchema.extend({
+  user: UserProfileSchema
+});
+var ChatMessageSchema = z24.object({
+  id: z24.string().uuid(),
+  conversation_id: z24.string().uuid(),
+  sender_id: z24.string().uuid(),
+  body: z24.string().min(1).max(4e3),
+  attachment_url: z24.string().nullable(),
+  attachment_type: z24.string().nullable(),
+  mentions: z24.array(z24.string().uuid()),
+  reply_to_id: z24.string().uuid().nullable().default(null),
+  created_at: z24.string().datetime({ offset: true }),
+  updated_at: z24.string().datetime({ offset: true }),
+  deleted_at: z24.string().datetime({ offset: true }).nullable()
+});
+var ReplyPreviewSchema = z24.object({
+  id: z24.string().uuid(),
+  sender_id: z24.string().uuid(),
+  sender_name: z24.string(),
+  body: z24.string()
+});
+var ReactionAggregateSchema = z24.object({
+  emoji: z24.string().min(1),
+  count: z24.number().int().min(1),
+  userIds: z24.array(z24.string().uuid())
+});
+var ChatMessageWithReactionsSchema = ChatMessageSchema.extend({
+  sender: UserProfileSchema,
+  reactions: z24.array(ReactionAggregateSchema),
+  reply_to: ReplyPreviewSchema.nullable().default(null)
+});
+var ChatReactionSchema = z24.object({
+  id: z24.string().uuid(),
+  message_id: z24.string().uuid(),
+  user_id: z24.string().uuid(),
+  emoji: z24.string().min(1),
+  created_at: z24.string().datetime({ offset: true })
+});
+var ChatReadCursorSchema = z24.object({
+  id: z24.string().uuid(),
+  conversation_id: z24.string().uuid(),
+  user_id: z24.string().uuid(),
+  last_read_message_id: z24.string().uuid(),
+  last_read_at: z24.string().datetime({ offset: true })
+});
+var PushSubscriptionSchema = z24.object({
+  id: z24.string().uuid(),
+  user_id: z24.string().uuid(),
+  platform: PushPlatformSchema,
+  token: z24.string().min(1),
+  created_at: z24.string().datetime({ offset: true }),
+  updated_at: z24.string().datetime({ offset: true })
+});
+var NotificationPreferencesSchema = z24.object({
+  id: z24.string(),
+  user_id: z24.string().uuid(),
+  push_enabled: z24.boolean(),
+  push_dms: z24.boolean(),
+  push_group: z24.boolean(),
+  push_mentions: z24.boolean(),
+  quiet_hours_start: z24.string().nullable(),
+  quiet_hours_end: z24.string().nullable(),
+  updated_at: z24.string().datetime({ offset: true }),
+  chat_enter_sends: z24.boolean().default(true)
+});
+var CreateDMSchema = z24.object({
+  type: z24.literal("direct"),
+  participantId: z24.string().uuid()
+});
+var CreateGroupSchema = z24.object({
+  type: z24.literal("group"),
+  name: z24.string().min(1).max(50).refine((n) => n.toLowerCase() !== "general", { message: 'The name "general" is reserved' }),
+  participantIds: z24.array(z24.string().uuid()).min(2)
+});
+var CreateConversationSchema = z24.discriminatedUnion("type", [
+  CreateDMSchema,
+  CreateGroupSchema
+]);
+var SendMessageSchema = z24.object({
+  conversationId: z24.string().uuid(),
+  body: z24.string().max(4e3),
+  attachmentUrl: z24.string().optional(),
+  attachmentType: z24.string().optional(),
+  mentions: z24.array(z24.string().uuid()).optional(),
+  replyToId: z24.string().uuid().optional()
+}).refine((d) => d.body.length > 0 || !!d.attachmentUrl, { message: "Either body or attachmentUrl is required" });
+var UpdateMessageSchema = z24.object({
+  messageId: z24.string().uuid(),
+  body: z24.string().min(1).max(4e3)
+});
+var CreatePushSubscriptionSchema = z24.object({
+  platform: PushPlatformSchema,
+  token: z24.string().min(1)
+});
+var UpdateNotificationPreferencesSchema = z24.object({
+  push_enabled: z24.boolean().optional(),
+  push_dms: z24.boolean().optional(),
+  push_group: z24.boolean().optional(),
+  push_mentions: z24.boolean().optional(),
+  quiet_hours_start: z24.string().nullable().optional(),
+  quiet_hours_end: z24.string().nullable().optional(),
+  chat_enter_sends: z24.boolean().optional()
+});
+var WsMessageSendSchema = z24.object({
+  type: z24.literal("message:send"),
+  payload: SendMessageSchema
+});
+var WsMessageEditSchema = z24.object({
+  type: z24.literal("message:edit"),
+  payload: UpdateMessageSchema
+});
+var WsMessageDeleteSchema = z24.object({
+  type: z24.literal("message:delete"),
+  payload: z24.object({ messageId: z24.string().uuid() })
+});
+var WsTypingStartSchema = z24.object({
+  type: z24.literal("typing:start"),
+  payload: z24.object({ conversationId: z24.string().uuid() })
+});
+var WsTypingStopSchema = z24.object({
+  type: z24.literal("typing:stop"),
+  payload: z24.object({ conversationId: z24.string().uuid() })
+});
+var WsReactionAddSchema = z24.object({
+  type: z24.literal("reaction:add"),
+  payload: z24.object({ messageId: z24.string().uuid(), emoji: z24.string().min(1) })
+});
+var WsReactionRemoveSchema = z24.object({
+  type: z24.literal("reaction:remove"),
+  payload: z24.object({ messageId: z24.string().uuid(), emoji: z24.string().min(1) })
+});
+var WsCursorUpdateSchema = z24.object({
+  type: z24.literal("cursor:update"),
+  payload: z24.object({
+    conversationId: z24.string().uuid(),
+    lastReadMessageId: z24.string().uuid()
+  })
+});
+var WsPingSchema = z24.object({
+  type: z24.literal("ping"),
+  payload: z24.object({})
+});
+var WsChatClientEvents = [
+  WsMessageSendSchema,
+  WsMessageEditSchema,
+  WsMessageDeleteSchema,
+  WsTypingStartSchema,
+  WsTypingStopSchema,
+  WsReactionAddSchema,
+  WsReactionRemoveSchema,
+  WsCursorUpdateSchema,
+  WsPingSchema,
+  WsCallStartSchema,
+  WsCallAcceptSchema,
+  WsCallDeclineSchema,
+  WsCallLeaveSchema,
+  WsCallEndSchema,
+  WsStatusSetSchema
+];
+var WsClientEventSchema = z24.discriminatedUnion("type", [
+  ...WsChatClientEvents,
+  ...WsBoardClientEvents
+]);
+var WsServerMessageNewSchema = z24.object({
+  type: z24.literal("message:new"),
+  payload: z24.object({ projectId: z24.string().uuid(), message: ChatMessageWithReactionsSchema })
+});
+var WsServerMessageUpdatedSchema = z24.object({
+  type: z24.literal("message:updated"),
+  payload: z24.object({ projectId: z24.string().uuid(), message: ChatMessageWithReactionsSchema })
+});
+var WsServerMessageDeletedSchema = z24.object({
+  type: z24.literal("message:deleted"),
+  payload: z24.object({ projectId: z24.string().uuid(), messageId: z24.string().uuid(), conversationId: z24.string().uuid() })
+});
+var WsServerTypingUpdateSchema = z24.object({
+  type: z24.literal("typing:update"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    conversationId: z24.string().uuid(),
+    userId: z24.string().uuid(),
+    isTyping: z24.boolean()
+  })
+});
+var WsServerPresenceJoinSchema = z24.object({
+  type: z24.literal("presence:join"),
+  payload: z24.object({ userId: z24.string().uuid(), projectId: z24.string().uuid() })
+});
+var WsServerPresenceLeaveSchema = z24.object({
+  type: z24.literal("presence:leave"),
+  payload: z24.object({ userId: z24.string().uuid(), projectId: z24.string().uuid() })
+});
+var WsServerPresenceStateSchema = z24.object({
+  type: z24.literal("presence:state"),
+  payload: z24.object({
+    online: z24.array(z24.string().uuid()),
+    statuses: z24.record(z24.string(), UserStatusSchema).optional()
+  })
+});
+var WsServerReactionAddedSchema = z24.object({
+  type: z24.literal("reaction:added"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    messageId: z24.string().uuid(),
+    reaction: z24.object({
+      userId: z24.string().uuid(),
+      emoji: z24.string().min(1)
+    })
+  })
+});
+var WsServerReactionRemovedSchema = z24.object({
+  type: z24.literal("reaction:removed"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    messageId: z24.string().uuid(),
+    userId: z24.string().uuid(),
+    emoji: z24.string().min(1)
+  })
+});
+var WsServerCursorUpdatedSchema = z24.object({
+  type: z24.literal("cursor:updated"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    conversationId: z24.string().uuid(),
+    userId: z24.string().uuid(),
+    lastReadMessageId: z24.string().uuid()
+  })
+});
+var WsServerPongSchema = z24.object({
+  type: z24.literal("pong"),
+  payload: z24.object({})
+});
+var WsServerErrorSchema = z24.object({
+  type: z24.literal("error"),
+  payload: z24.object({ code: z24.string(), message: z24.string() })
+});
+var WsServerSubscriptionUpdateSchema = z24.object({
+  type: z24.literal("subscription:update"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    action: z24.enum(["added", "removed"]),
+    project: z24.object({
+      id: z24.string().uuid(),
+      name: z24.string(),
+      role: z24.string()
+    }).optional()
+  })
+});
+var WsServerConversationCreatedSchema = z24.object({
+  type: z24.literal("conversation:created"),
+  payload: z24.object({
+    conversation: ChatConversationWithPreviewSchema
+  })
+});
+var WsServerConversationUpdatedSchema = z24.object({
+  type: z24.literal("conversation:updated"),
+  payload: z24.object({
+    conversationId: z24.string().uuid(),
+    changes: z24.object({
+      name: z24.string().optional(),
+      participantsAdded: z24.array(z24.string().uuid()).optional(),
+      participantsRemoved: z24.array(z24.string().uuid()).optional()
+    })
+  })
+});
+var WsServerConversationDeletedSchema = z24.object({
+  type: z24.literal("conversation:deleted"),
+  payload: z24.object({
+    conversationId: z24.string().uuid(),
+    projectId: z24.string().uuid()
+  })
+});
+var WsServerUnreadSyncSchema = z24.object({
+  type: z24.literal("unread:sync"),
+  payload: z24.object({
+    projects: z24.array(z24.object({ projectId: z24.string().uuid(), count: z24.number().int().min(0) })),
+    conversations: z24.array(z24.object({ conversationId: z24.string().uuid(), count: z24.number().int().min(0) }))
+  })
+});
+var WsServerDocumentCreatedSchema = z24.object({
+  type: z24.literal("document:created"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    spaceId: z24.string().uuid(),
+    document: z24.object({ id: z24.string().uuid(), title: z24.string() })
+  })
+});
+var WsServerDocumentUpdatedSchema = z24.object({
+  type: z24.literal("document:updated"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    spaceId: z24.string().uuid(),
+    document: z24.object({ id: z24.string().uuid(), title: z24.string() })
+  })
+});
+var WsServerDocumentDeletedSchema = z24.object({
+  type: z24.literal("document:deleted"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    spaceId: z24.string().uuid(),
+    documentId: z24.string().uuid()
+  })
+});
+var WsServerSpaceCreatedSchema = z24.object({
+  type: z24.literal("space:created"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    space: z24.object({ id: z24.string().uuid(), name: z24.string() })
+  })
+});
+var WsServerSpaceUpdatedSchema = z24.object({
+  type: z24.literal("space:updated"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    space: z24.object({ id: z24.string().uuid(), name: z24.string() })
+  })
+});
+var WsServerSpaceDeletedSchema = z24.object({
+  type: z24.literal("space:deleted"),
+  payload: z24.object({
+    projectId: z24.string().uuid(),
+    spaceId: z24.string().uuid()
+  })
+});
+var WsChatServerEvents = [
+  WsServerMessageNewSchema,
+  WsServerMessageUpdatedSchema,
+  WsServerMessageDeletedSchema,
+  WsServerTypingUpdateSchema,
+  WsServerPresenceJoinSchema,
+  WsServerPresenceLeaveSchema,
+  WsServerPresenceStateSchema,
+  WsServerReactionAddedSchema,
+  WsServerReactionRemovedSchema,
+  WsServerCursorUpdatedSchema,
+  WsServerPongSchema,
+  WsServerErrorSchema,
+  WsServerSubscriptionUpdateSchema,
+  WsServerConversationCreatedSchema,
+  WsServerConversationUpdatedSchema,
+  WsServerConversationDeletedSchema,
+  WsServerUnreadSyncSchema,
+  WsServerDocumentCreatedSchema,
+  WsServerDocumentUpdatedSchema,
+  WsServerDocumentDeletedSchema,
+  WsServerSpaceCreatedSchema,
+  WsServerSpaceUpdatedSchema,
+  WsServerSpaceDeletedSchema,
+  WsServerCallRingSchema,
+  WsServerCallStartedSchema,
+  WsServerCallParticipantJoinedSchema,
+  WsServerCallParticipantLeftSchema,
+  WsServerCallEndedSchema,
+  WsServerCallDeclinedSchema,
+  WsServerCallMissedSchema,
+  WsServerStatusUpdateSchema
+];
+var WsServerEventSchema = z24.discriminatedUnion("type", [
+  ...WsChatServerEvents,
+  ...WsBoardServerEvents
+]);
+
+// ../types/dist/api-token.schema.js
+import { z as z25 } from "zod";
+var ApiTokenMetadataSchema = z25.object({
+  id: z25.string().uuid(),
+  name: z25.string().min(1),
+  token_prefix: z25.string(),
+  last_used_at: z25.string().datetime({ offset: true }).nullable(),
+  created_at: z25.string().datetime({ offset: true })
+});
+var GenerateApiTokenResponseSchema = z25.object({
+  id: z25.string().uuid(),
+  name: z25.string().min(1),
+  token_prefix: z25.string(),
+  token: z25.string(),
+  created_at: z25.string().datetime({ offset: true })
+});
+var CreateApiTokenBodySchema = z25.object({
+  name: z25.string().min(1).max(100).optional().default("Claude Code")
+});
+
+// ../types/dist/doc-space.schema.js
+import { z as z26 } from "zod";
+var DocSpaceSchema = z26.object({
+  id: z26.string().uuid(),
+  project_id: z26.string().uuid(),
+  name: z26.string().min(1).max(100),
+  prefix: z26.string().regex(/^[A-Z]{2,10}$/),
+  doc_counter: z26.number().int().nonnegative(),
+  created_at: z26.string().datetime({ offset: true }),
+  updated_at: z26.string().datetime({ offset: true })
+});
+var DocSpaceWithCountSchema = DocSpaceSchema.extend({
+  document_count: z26.number().int().nonnegative(),
+  can_write: z26.boolean()
+});
+var CreateDocSpaceSchema = z26.object({
+  name: z26.string().trim().min(1).max(100),
+  prefix: z26.string().regex(/^[A-Z]{2,10}$/)
+});
+var UpdateDocSpaceSchema = z26.object({
+  name: z26.string().trim().min(1).max(100).optional(),
+  prefix: z26.string().regex(/^[A-Z]{2,10}$/).optional()
+});
+var DocumentActionSchema = z26.enum(["delete", "move"]);
+var DeleteDocSpaceBodySchema = z26.object({
+  document_action: DocumentActionSchema.default("delete"),
+  target_space_id: z26.string().uuid().optional()
+}).superRefine((data, ctx) => {
+  if (data.document_action === "move" && !data.target_space_id) {
+    ctx.addIssue({
+      code: z26.ZodIssueCode.custom,
+      message: "target_space_id is required when document_action is move",
+      path: ["target_space_id"]
+    });
+  }
+});
+var DeleteDocSpacePreviewSchema = z26.object({
+  documents: z26.number().int().nonnegative()
+});
+
+// ../types/dist/document.schema.js
+import { z as z27 } from "zod";
+var DocumentSchema = z27.object({
+  id: z27.string().uuid(),
+  space_id: z27.string().uuid(),
+  project_id: z27.string().uuid(),
+  parent_id: z27.string().uuid().nullable(),
+  doc_number: z27.number().int().positive(),
+  title: z27.string().min(1).max(500),
+  content: z27.string(),
+  position: z27.number().int(),
+  created_by: z27.string().uuid(),
+  updated_by: z27.string().uuid(),
+  created_at: z27.string().datetime({ offset: true }),
+  updated_at: z27.string().datetime({ offset: true })
+});
+var DocumentWithProfilesSchema = DocumentSchema.extend({
+  creator: UserProfileSchema,
+  updater: UserProfileSchema
+});
+var DocumentTreeNodeSchema = DocumentSchema.extend({
+  children: z27.lazy(() => DocumentTreeNodeSchema.array())
+});
+var CreateDocumentSchema = z27.object({
+  title: z27.string().trim().min(1).max(500),
+  content: z27.string().optional().default(""),
+  parent_id: z27.string().uuid().nullable().optional().default(null)
+});
+var UpdateDocumentSchema = z27.object({
+  title: z27.string().trim().min(1).max(500).optional(),
+  content: z27.string().optional()
+});
+var MoveDocumentSchema = z27.object({
+  parent_id: z27.string().uuid().nullable().optional(),
+  position: z27.number().int().nonnegative().optional()
+});
+var DeleteDocumentPreviewSchema = z27.object({
+  child_documents: z27.number().int().nonnegative()
+});
+
+// ../types/dist/search.schema.js
+import { z as z28 } from "zod";
+var SearchResultTypeSchema = z28.enum(["ticket", "document", "message"]);
+var SearchResultSchema = z28.object({
+  type: SearchResultTypeSchema,
+  id: z28.string().uuid(),
+  display_id: z28.string().nullable(),
+  project_id: z28.string().uuid(),
+  project_name: z28.string(),
+  title: z28.string(),
+  snippet: z28.string(),
+  meta: z28.record(z28.string(), z28.unknown()).optional()
+});
+var SearchQuerySchema = z28.object({
+  q: z28.string().min(2),
+  type: SearchResultTypeSchema.optional(),
+  project_id: z28.string().uuid().optional(),
+  limit: z28.coerce.number().int().min(1).max(50).optional().default(20)
+});
+var SearchResponseSchema = z28.object({
+  results: z28.array(SearchResultSchema),
+  total: z28.number().int().nonnegative()
+});
+var MentionResultTypeSchema = z28.enum(["ticket", "document", "user"]);
+var MentionResultSchema = z28.object({
+  type: MentionResultTypeSchema,
+  id: z28.string().uuid(),
+  displayId: z28.string(),
+  title: z28.string(),
+  avatarUrl: z28.string().optional()
+});
+
+// ../types/dist/entity-reference.schema.js
+import { z as z29 } from "zod";
+var EntityReferenceSourceTypeSchema = z29.enum(["ticket", "document", "comment", "chat_message"]);
+var EntityReferenceTargetTypeSchema = z29.enum(["ticket", "document"]);
+var EntityReferenceSchema = z29.object({
+  id: z29.string().uuid(),
+  source_type: EntityReferenceSourceTypeSchema,
+  source_id: z29.string().uuid(),
+  target_type: EntityReferenceTargetTypeSchema,
+  target_id: z29.string().uuid(),
+  project_id: z29.string().uuid(),
+  created_at: z29.string().datetime({ offset: true })
+});
+var BacklinkSchema = z29.object({
+  source_type: EntityReferenceSourceTypeSchema,
+  source_id: z29.string().uuid(),
+  display_id: z29.string(),
+  title: z29.string()
+});
+var BacklinksResponseSchema = z29.object({
+  backlinks: z29.array(BacklinkSchema),
+  total: z29.number().int().nonnegative()
+});
+var ResolveResultSchema = z29.object({
+  type: EntityReferenceTargetTypeSchema,
+  id: z29.string().uuid(),
+  boardId: z29.string().uuid().optional(),
+  spaceId: z29.string().uuid().optional()
+});
+var BatchResolveResponseSchema = z29.object({
+  results: z29.record(z29.string(), ResolveResultSchema)
+});
+
+// ../types/dist/notification.schema.js
+import { z as z30 } from "zod";
+var NotificationTypeSchema = z30.enum(["mention"]);
+var NotificationSchema = z30.object({
+  id: z30.string().uuid(),
+  project_id: z30.string().uuid(),
+  user_id: z30.string().uuid(),
+  actor_id: z30.string().uuid(),
+  type: NotificationTypeSchema,
+  source_type: z30.string(),
+  source_id: z30.string().uuid(),
+  display_id: z30.string(),
+  title: z30.string(),
+  read: z30.boolean(),
+  created_at: z30.string().datetime({ offset: true })
+});
+var NotificationWithActorSchema = NotificationSchema.extend({
+  actor: z30.object({
+    id: z30.string().uuid(),
+    display_name: z30.string(),
+    avatar_url: z30.string().nullable()
+  }).nullable()
+});
+var NotificationsResponseSchema = z30.object({
+  notifications: z30.array(NotificationWithActorSchema),
+  unread_count: z30.number().int().nonnegative()
+});
+
+// ../types/dist/field-value.schema.js
+import { z as z31 } from "zod";
+var FieldValueSchema = z31.object({
+  id: z31.string().uuid(),
+  ticket_id: z31.string().uuid(),
+  field_id: z31.string().uuid(),
+  text_value: z31.string().nullable(),
+  number_value: z31.number().nullable(),
+  date_value: z31.string().nullable(),
+  json_value: z31.unknown().nullable(),
+  ref_user_id: z31.string().uuid().nullable(),
+  ref_ticket_id: z31.string().uuid().nullable(),
+  ref_document_id: z31.string().uuid().nullable(),
+  created_at: z31.string().datetime({ offset: true }),
+  updated_at: z31.string().datetime({ offset: true })
+});
+var FieldValueWithDefinitionSchema = FieldValueSchema.extend({
+  field_name: z31.string(),
+  field_type: z31.string()
+});
+var SetFieldValueSchema = z31.object({
+  value: z31.unknown()
+});
+var BatchSetFieldValuesSchema = z31.object({
+  values: z31.record(z31.string(), z31.unknown())
+});
+
+// ../types/dist/transition-requirement.schema.js
+import { z as z32 } from "zod";
+var TransitionFieldRequirementSchema = z32.object({
+  id: z32.string().uuid(),
+  board_id: z32.string().uuid(),
+  to_column_id: z32.string().uuid().nullable(),
+  field_id: z32.string().uuid(),
+  to_tombstone_id: z32.string().uuid().nullable(),
+  status: TransitionRuleStatusSchema,
+  instruction: z32.string().nullable(),
+  created_at: z32.string().datetime({ offset: true }),
+  updated_at: z32.string().datetime({ offset: true })
+});
+var TransitionFieldRequirementWithTombstoneSchema = TransitionFieldRequirementSchema.extend({
+  to_tombstone_name: z32.string().nullable().default(null),
+  field_name: z32.string().default(""),
+  field_type: z32.string().default("")
+});
+var BulkUpsertTransitionRequirementsSchema = z32.object({
+  requirements: z32.array(z32.object({
+    to_column_id: z32.string().uuid(),
+    field_id: z32.string().uuid(),
+    instruction: z32.string().nullable().optional()
+  }))
+});
+
+// ../types/dist/transition-blocked.schema.js
+import { z as z33 } from "zod";
+var ColumnInfoSchema = z33.object({
+  id: z33.string().uuid(),
+  name: z33.string()
+});
+var WorkflowViolationSchema = z33.object({
+  type: z33.literal("workflow"),
+  message: z33.string(),
+  from_column: ColumnInfoSchema,
+  to_column: ColumnInfoSchema,
+  allowed_targets: z33.array(ColumnInfoSchema)
+});
+var MissingFieldsViolationSchema = z33.object({
+  type: z33.literal("missing_fields"),
+  message: z33.string(),
+  fields: z33.array(z33.object({
+    field_id: z33.string().uuid(),
+    name: z33.string(),
+    type: z33.string(),
+    config: z33.record(z33.string(), z33.unknown()).default({})
+  }))
+});
+var UnresolvedDependenciesViolationSchema = z33.object({
+  type: z33.literal("unresolved_dependencies"),
+  message: z33.string(),
+  blocking_tickets: z33.array(z33.object({
+    id: z33.string().uuid(),
+    ticket_number: z33.number().int(),
+    title: z33.string(),
+    column: z33.string()
+  }))
+});
+var TransitionViolationSchema = z33.discriminatedUnion("type", [
+  WorkflowViolationSchema,
+  MissingFieldsViolationSchema,
+  UnresolvedDependenciesViolationSchema
+]);
+var TransitionBlockedErrorSchema = z33.object({
+  success: z33.literal(false),
+  error: z33.object({
+    code: z33.literal("TRANSITION_BLOCKED"),
+    violations: z33.array(TransitionViolationSchema)
+  })
+});
+
+// ../types/dist/ticket-link.schema.js
+import { z as z34 } from "zod";
+var TicketLinkTypeSchema = z34.enum(["blocks", "relates_to", "duplicates"]);
+var ResolvedWhenSchema = z34.discriminatedUnion("type", [
+  z34.object({
+    type: z34.literal("column"),
+    column_ids: z34.array(z34.string().uuid()).min(1)
+  }),
+  z34.object({
+    type: z34.literal("archived")
+  }),
+  z34.object({
+    type: z34.literal("column_or_archived"),
+    column_ids: z34.array(z34.string().uuid())
+  })
+]);
+var TicketLinkSchema = z34.object({
+  id: z34.string().uuid(),
+  source_id: z34.string().uuid(),
+  target_id: z34.string().uuid(),
+  link_type: TicketLinkTypeSchema,
+  project_id: z34.string().uuid(),
+  created_by: z34.string().uuid(),
+  created_at: z34.string().datetime({ offset: true }),
+  updated_at: z34.string().datetime({ offset: true }),
+  resolved_at: z34.string().datetime({ offset: true }).nullable().optional(),
+  resolved_by: z34.string().uuid().nullable().optional()
+});
+var TicketLinkWithDetailsSchema = TicketLinkSchema.extend({
+  source: z34.object({
+    id: z34.string().uuid(),
+    ticket_number: z34.number().int(),
+    title: z34.string(),
+    column_name: z34.string().nullable()
+  }),
+  target: z34.object({
+    id: z34.string().uuid(),
+    ticket_number: z34.number().int(),
+    title: z34.string(),
+    column_name: z34.string().nullable()
+  })
+});
+var CreateTicketLinkSchema = z34.object({
+  source_ticket_id: z34.string().uuid(),
+  target_ticket_id: z34.string().uuid(),
+  link_type: TicketLinkTypeSchema
+});
+var DependencyRequirementSchema = z34.object({
+  id: z34.string().uuid(),
+  board_id: z34.string().uuid(),
+  to_column_id: z34.string().uuid().nullable().optional(),
+  to_tombstone_id: z34.string().uuid().nullable().optional(),
+  instruction: z34.string().nullable().optional(),
+  status: z34.enum(["active", "broken"]),
+  resolved_when: ResolvedWhenSchema.nullable().optional(),
+  created_at: z34.string().datetime({ offset: true }),
+  updated_at: z34.string().datetime({ offset: true })
+});
+
+// ../types/dist/column-tombstone.schema.js
+import { z as z35 } from "zod";
+var ColumnTombstoneSchema = z35.object({
+  id: z35.string().uuid(),
+  board_id: z35.string().uuid(),
+  name: z35.string(),
+  color: z35.string(),
+  deleted_at: z35.string().datetime({ offset: true })
+});
+
+// ../types/dist/gif.schema.js
+import { z as z36 } from "zod";
+var GifSchema = z36.object({
+  id: z36.string(),
+  title: z36.string(),
+  url: z36.string().url(),
+  preview_url: z36.string().url(),
+  width: z36.number().int(),
+  height: z36.number().int()
+});
+var GifSearchQuerySchema = z36.object({
+  q: z36.string().min(1).max(100)
+});
+var GifResponseSchema = z36.object({
+  gifs: z36.array(GifSchema)
+});
+
+// ../types/dist/preferences.schema.js
+import { z as z37 } from "zod";
+var ThemePaletteSchema = z37.enum(["kantban", "seventies-coffee"]);
+var ThemeModeSchema = z37.enum(["light", "dark", "system"]);
+var UserPreferencesSchema = z37.object({
+  user_id: z37.string().uuid(),
+  theme_palette: ThemePaletteSchema,
+  theme_mode: ThemeModeSchema
+});
+var UpdateUserPreferencesSchema = z37.object({
+  theme_palette: ThemePaletteSchema.optional(),
+  theme_mode: ThemeModeSchema.optional()
+});
+
+// ../types/dist/activity.schema.js
+import { z as z38 } from "zod";
+var ActivityActionSchema = z38.enum([
+  "ticket_created",
+  "ticket_moved",
+  "ticket_updated",
+  "comment_added",
+  "field_changed",
+  "ticket_archived",
+  "github_reference_created",
+  "github_reference_updated",
+  "template_executed",
+  "sprint_closed",
+  "signal_created",
+  "document_updated",
+  "board_updated",
+  "column_updated",
+  "signal_deleted",
+  "transition_rule_changed",
+  "firing_constraint_created",
+  "firing_constraint_updated",
+  "firing_constraint_deleted",
+  "pipeline_session_completed"
+]);
+var ActivityResourceTypeSchema = z38.enum([
+  "ticket",
+  "comment",
+  "field_value",
+  "board",
+  "document",
+  "ticket_reference",
+  "pipeline_template",
+  "signal",
+  "column",
+  "pipeline_session"
+]);
+var ActivityLogSchema = z38.object({
+  id: z38.string().uuid(),
+  project_id: z38.string().uuid(),
+  actor_id: z38.string().uuid(),
+  action: ActivityActionSchema,
+  resource_type: ActivityResourceTypeSchema,
+  resource_id: z38.string().uuid(),
+  board_id: z38.string().uuid().nullable().default(null),
+  ticket_id: z38.string().uuid().nullable().default(null),
+  metadata: z38.record(z38.string(), z38.unknown()).default({}),
+  created_at: z38.string().datetime({ offset: true })
+});
+var ActivityFeedQuerySchema = z38.object({
+  since: z38.string().datetime({ offset: true }).optional(),
+  types: z38.string().optional(),
+  via: z38.string().optional(),
+  boardId: z38.string().uuid().optional(),
+  ticketId: z38.string().uuid().optional(),
+  columnId: z38.string().uuid().optional(),
+  sessionId: z38.string().uuid().optional(),
+  limit: z38.coerce.number().int().min(1).max(200).optional().default(20),
+  cursor: z38.string().optional()
+});
+
+// ../types/dist/ticket-metrics.schema.js
+import { z as z39 } from "zod";
+var TicketMetricsSchema = z39.object({
+  ticket_id: z39.string().uuid(),
+  board_id: z39.string().uuid(),
+  project_id: z39.string().uuid(),
+  created_at: z39.string().datetime({ offset: true }),
+  first_active_at: z39.string().datetime({ offset: true }).nullable(),
+  done_at: z39.string().datetime({ offset: true }),
+  lead_time_hours: z39.number(),
+  cycle_time_hours: z39.number().nullable(),
+  column_transitions: z39.number().int(),
+  backward_moves: z39.number().int(),
+  assignee_changes: z39.number().int(),
+  labels: z39.record(z39.string(), z39.unknown()).default({})
+});
+
+// ../types/dist/daily-snapshot.schema.js
+import { z as z40 } from "zod";
+var DailySnapshotSchema = z40.object({
+  id: z40.string().uuid(),
+  project_id: z40.string().uuid(),
+  board_id: z40.string().uuid(),
+  snapshot_date: z40.string(),
+  column_id: z40.string().uuid(),
+  column_name: z40.string(),
+  ticket_count: z40.number().int()
+});
+
+// ../types/dist/compound.schema.js
+import { z as z41 } from "zod";
+var PlanItemSchema = z41.object({
+  title: z41.string().min(1).max(500),
+  description: z41.string().max(1e4).optional(),
+  columnName: z41.string().optional(),
+  fieldValues: z41.record(z41.string(), z41.unknown()).optional(),
+  subtasks: z41.array(z41.object({
+    title: z41.string().min(1).max(500),
+    description: z41.string().max(1e4).optional()
+  })).optional()
+});
+var PlanToTicketsBodySchema = z41.object({
+  plan: z41.array(PlanItemSchema).min(1).max(50),
+  dryRun: z41.boolean().optional().default(true)
+});
+var SuggestNextTaskQuerySchema = z41.object({
+  boardId: z41.string().uuid().optional(),
+  userId: z41.string().uuid().optional(),
+  count: z41.coerce.number().optional().default(5)
+});
+var TaskScoreSchema = z41.object({
+  ticketId: z41.string().uuid(),
+  ticketNumber: z41.number(),
+  title: z41.string(),
+  score: z41.number(),
+  breakdown: z41.record(z41.string(), z41.number()),
+  reasoning: z41.string(),
+  columnName: z41.string(),
+  boardName: z41.string(),
+  assigneeName: z41.string().nullable(),
+  timeInColumn: z41.number(),
+  timeUnit: z41.enum(["minutes", "hours", "days"]).default("days")
+});
+var StartWorkingBodySchema = z41.object({
+  moveToColumn: z41.string().optional()
+});
+var CompleteTaskBodySchema = z41.object({
+  moveToColumn: z41.string().optional(),
+  completionComment: z41.string().max(1e4).optional(),
+  suggestNext: z41.boolean().optional().default(true),
+  handoff: z41.record(z41.string(), z41.unknown()).optional()
+});
+var BottleneckResultSchema = z41.object({
+  wip_violations: z41.array(z41.object({
+    column: z41.string(),
+    limit: z41.number(),
+    actual: z41.number(),
+    tickets: z41.array(z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() }))
+  })),
+  stuck_tickets: z41.array(z41.object({
+    ticket: z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() }),
+    column: z41.string(),
+    time_in_column: z41.number(),
+    time_unit: z41.enum(["minutes", "hours", "days"]).default("days"),
+    last_activity_at: z41.string().nullable()
+  })),
+  blocked_chains: z41.array(z41.object({
+    blocking_ticket: z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() }),
+    blocked_tickets: z41.array(z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() })),
+    reason: z41.string()
+  })),
+  unassigned_active: z41.array(z41.object({
+    ticket: z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() }),
+    column: z41.string()
+  })),
+  suggestions: z41.array(z41.string()),
+  circuit_breaker_proximity: z41.array(z41.object({
+    ticket: z41.object({ id: z41.string(), title: z41.string(), ticket_number: z41.number() }),
+    column: z41.string(),
+    backward_transitions: z41.number(),
+    threshold: z41.number()
+  })).optional()
+});
+var TicketContextSchema = z41.object({
+  ticket: z41.record(z41.string(), z41.unknown()),
+  comments: z41.array(z41.record(z41.string(), z41.unknown())),
+  field_values: z41.array(z41.record(z41.string(), z41.unknown())),
+  linked_tickets: z41.array(z41.record(z41.string(), z41.unknown())),
+  linked_documents: z41.array(z41.record(z41.string(), z41.unknown())),
+  references: z41.array(z41.record(z41.string(), z41.unknown())),
+  signals: z41.array(z41.record(z41.string(), z41.unknown())).optional(),
+  transitions: z41.array(z41.record(z41.string(), z41.unknown())).optional()
+});
+var ChunkedSearchBodySchema = z41.object({
+  query: z41.string().min(1),
+  maxChunks: z41.number().optional().default(5)
+});
+
+// ../types/dist/dashboard.schema.js
+import { z as z42 } from "zod";
+var DashboardBoardSummarySchema = z42.object({
+  id: z42.string().uuid(),
+  name: z42.string(),
+  columns: z42.array(z42.object({
+    id: z42.string().uuid(),
+    name: z42.string(),
+    ticket_count: z42.number(),
+    wip_limit: z42.number().nullable()
+  })),
+  total_tickets: z42.number()
+});
+var DashboardProjectSchema = z42.object({
+  id: z42.string().uuid(),
+  name: z42.string(),
+  ticket_prefix: z42.string(),
+  boards: z42.array(DashboardBoardSummarySchema),
+  my_tickets: z42.array(z42.object({
+    id: z42.string().uuid(),
+    ticket_number: z42.number(),
+    title: z42.string(),
+    board_name: z42.string(),
+    column_name: z42.string().nullable(),
+    time_in_column: z42.number().nullable(),
+    time_unit: z42.enum(["minutes", "hours", "days"]).default("days")
+  }))
+});
+var UserDashboardSchema = z42.object({
+  projects: z42.array(DashboardProjectSchema),
+  urgent: z42.array(z42.object({
+    type: z42.string(),
+    message: z42.string(),
+    ticket_id: z42.string().uuid().optional(),
+    board_id: z42.string().uuid().optional()
+  }))
+});
+
+// ../types/dist/github.schema.js
+import { z as z43 } from "zod";
+var GithubConnectionSchema = z43.object({
+  id: z43.string().uuid(),
+  user_id: z43.string().uuid(),
+  github_user_id: z43.string(),
+  github_username: z43.string(),
+  scopes: z43.array(z43.string()),
+  created_at: z43.string().datetime({ offset: true })
+});
+var ProjectGithubRepoSchema = z43.object({
+  id: z43.string().uuid(),
+  project_id: z43.string().uuid(),
+  github_repo_owner: z43.string(),
+  github_repo_name: z43.string(),
+  github_repo_id: z43.number().int(),
+  connected_by: z43.string().uuid(),
+  webhook_id: z43.number().int().nullable(),
+  created_at: z43.string().datetime({ offset: true }),
+  updated_at: z43.string().datetime({ offset: true })
+});
+var ConnectGithubRepoBodySchema = z43.object({
+  repo_owner: z43.string().min(1),
+  repo_name: z43.string().min(1)
+});
+
+// ../types/dist/ticket-reference.schema.js
+import { z as z44 } from "zod";
+var TicketReferenceProviderSchema = z44.enum(["github"]);
+var TicketReferenceTypeSchema = z44.enum(["pull_request", "branch", "commit"]);
+var TicketReferenceStatusSchema = z44.enum(["open", "closed", "merged", "draft", "active", "deleted", "none"]);
+var TicketReferenceLinkedBySchema = z44.enum(["convention", "manual"]);
+var TicketReferenceSchema = z44.object({
+  id: z44.string().uuid(),
+  ticket_id: z44.string().uuid(),
+  project_id: z44.string().uuid(),
+  provider: TicketReferenceProviderSchema,
+  type: TicketReferenceTypeSchema,
+  external_id: z44.string(),
+  external_url: z44.string().url(),
+  title: z44.string(),
+  status: TicketReferenceStatusSchema,
+  metadata: z44.record(z44.string(), z44.unknown()).default({}),
+  linked_by: TicketReferenceLinkedBySchema,
+  synced_at: z44.string().datetime({ offset: true }).nullable(),
+  created_at: z44.string().datetime({ offset: true })
+});
+var LinkGithubReferenceBodySchema = z44.object({
+  type: TicketReferenceTypeSchema,
+  url: z44.string().url()
+});
+
+// ../types/dist/analytics.schema.js
+import { z as z45 } from "zod";
+var AnalyticsQuerySchema = z45.object({
+  boardId: z45.string().uuid().optional(),
+  since: z45.string().datetime({ offset: true }).optional(),
+  until: z45.string().datetime({ offset: true }).optional(),
+  assigneeId: z45.string().uuid().optional(),
+  resolution: z45.enum(["auto", "minutes", "hours", "days"]).optional().default("auto")
+});
+var VelocityQuerySchema = AnalyticsQuerySchema.extend({
+  weeks: z45.coerce.number().int().min(1).max(52).optional().default(8)
+});
+var ForecastQuerySchema = z45.object({
+  boardId: z45.string().uuid().optional(),
+  remainingTickets: z45.coerce.number().int().min(0).optional(),
+  targetDate: z45.string().date().optional()
+});
+var EstimationQuerySchema = z45.object({
+  ticketId: z45.string().uuid()
+});
+var RetrospectiveQuerySchema = AnalyticsQuerySchema.extend({
+  periodDays: z45.coerce.number().int().min(1).max(365).optional().default(14)
+});
+var VelocityWeekSchema = z45.object({
+  week_start: z45.string(),
+  completed: z45.number().int(),
+  avg_cycle_time_value: z45.number().nullable()
+});
+var VelocityResponseSchema = z45.object({
+  weeks: z45.array(VelocityWeekSchema),
+  trend: z45.enum(["up", "down", "stable"]),
+  avg_throughput: z45.number(),
+  time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+});
+var CycleTimeDataPointSchema = z45.object({
+  ticket_id: z45.string().uuid(),
+  ticket_number: z45.number().int().optional(),
+  title: z45.string().optional(),
+  done_at: z45.string(),
+  cycle_time_value: z45.number()
+});
+var CycleTimeResponseSchema = z45.object({
+  data_points: z45.array(CycleTimeDataPointSchema),
+  percentiles: z45.object({
+    p50: z45.number(),
+    p85: z45.number(),
+    p95: z45.number()
+  }),
+  avg_cycle_time_value: z45.number(),
+  total_tickets: z45.number().int(),
+  time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+});
+var LeadTimeBucketSchema = z45.object({
+  range_label: z45.string(),
+  min_hours: z45.number(),
+  max_hours: z45.number(),
+  count: z45.number().int()
+});
+var LeadTimeResponseSchema = z45.object({
+  buckets: z45.array(LeadTimeBucketSchema),
+  percentiles: z45.object({
+    p50: z45.number(),
+    p85: z45.number(),
+    p95: z45.number()
+  }),
+  avg_lead_time_value: z45.number(),
+  total_tickets: z45.number().int(),
+  time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+});
+var CfdColumnDataSchema = z45.object({
+  column_name: z45.string(),
+  count: z45.number().int()
+});
+var CfdDateEntrySchema = z45.object({
+  date: z45.string(),
+  columns: z45.array(CfdColumnDataSchema)
+});
+var CfdResponseSchema = z45.object({
+  entries: z45.array(CfdDateEntrySchema),
+  column_names: z45.array(z45.string())
+});
+var ForecastProbabilitySchema = z45.object({
+  confidence: z45.number(),
+  date: z45.string(),
+  weeks: z45.number()
+});
+var ForecastResponseSchema = z45.object({
+  remaining_tickets: z45.number().int(),
+  simulations: z45.number().int(),
+  probabilities: z45.array(ForecastProbabilitySchema),
+  target_date_probability: z45.number().nullable(),
+  weekly_throughput_avg: z45.number(),
+  weekly_throughput_stddev: z45.number(),
+  data_weeks: z45.number().int()
+});
+var EstimationResponseSchema = z45.object({
+  ticket_id: z45.string().uuid(),
+  similar_count: z45.number().int(),
+  cycle_time_estimate: z45.object({
+    min: z45.number(),
+    max: z45.number(),
+    avg: z45.number(),
+    median: z45.number(),
+    p85: z45.number()
+  }).nullable(),
+  similar_tickets: z45.array(z45.object({
+    ticket_id: z45.string().uuid(),
+    title: z45.string(),
+    cycle_time_value: z45.number(),
+    keyword_overlap: z45.number().int()
+  })),
+  time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+});
+var RetrospectiveInsightsSchema = z45.object({
+  period_days: z45.number().int(),
+  throughput: z45.object({
+    created: z45.number().int(),
+    completed: z45.number().int(),
+    net: z45.number().int()
+  }),
+  bottlenecks: z45.object({
+    high_backward_moves: z45.array(z45.object({
+      ticket_id: z45.string().uuid(),
+      backward_moves: z45.number().int()
+    })),
+    avg_backward_moves: z45.number()
+  }),
+  rework: z45.object({
+    total_backward_moves: z45.number().int(),
+    tickets_with_rework: z45.number().int()
+  }),
+  workload: z45.array(z45.object({
+    assignee_id: z45.string().uuid(),
+    completed: z45.number().int(),
+    avg_cycle_time_value: z45.number().nullable()
+  })),
+  wip: z45.object({
+    current_in_progress: z45.number().int()
+  }),
+  time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+});
+var BoardAnalyticsSummarySchema = z45.object({
+  velocity: VelocityResponseSchema,
+  cycle_time: z45.object({
+    avg_value: z45.number(),
+    p85_value: z45.number(),
+    total_completed: z45.number().int(),
+    time_unit: z45.enum(["minutes", "hours", "days"]).default("days")
+  }),
+  wip: z45.object({
+    current: z45.number().int(),
+    limit: z45.number().int().nullable()
+  })
+});
+
+// ../types/dist/pipeline-template.schema.js
+import { z as z46 } from "zod";
+var PipelineTemplateStepSchema = z46.object({
+  name: z46.string(),
+  tool: z46.string(),
+  description: z46.string(),
+  params: z46.record(z46.string(), z46.unknown()),
+  condition: z46.string().optional(),
+  onError: z46.enum(["stop", "skip", "warn"])
+});
+var PipelineTemplateSchema = z46.object({
+  id: z46.string().uuid(),
+  project_id: z46.string().uuid().nullable(),
+  name: z46.string(),
+  display_name: z46.string(),
+  description: z46.string(),
+  steps: z46.array(PipelineTemplateStepSchema),
+  parameters: z46.record(z46.string(), z46.unknown()).default({}),
+  is_builtin: z46.boolean(),
+  created_at: z46.string().datetime({ offset: true }),
+  updated_at: z46.string().datetime({ offset: true })
+});
+var CreatePipelineTemplateBodySchema = z46.object({
+  name: z46.string().min(1).max(100),
+  display_name: z46.string().min(1).max(200),
+  description: z46.string().max(2e3),
+  steps: z46.array(PipelineTemplateStepSchema).min(1),
+  parameters: z46.record(z46.string(), z46.unknown()).optional().default({})
+});
+var UpdatePipelineTemplateBodySchema = z46.object({
+  name: z46.string().min(1).max(100).optional(),
+  display_name: z46.string().min(1).max(200).optional(),
+  description: z46.string().max(2e3).optional(),
+  steps: z46.array(PipelineTemplateStepSchema).min(1).optional(),
+  parameters: z46.record(z46.string(), z46.unknown()).optional()
+});
+var RunPipelineTemplateBodySchema = z46.object({
+  parameters: z46.record(z46.string(), z46.unknown()).optional().default({}),
+  dryRun: z46.boolean().optional().default(true)
+});
+
+// ../types/dist/time-unit.js
+import { z as z47 } from "zod";
+var TimeUnitSchema = z47.enum(["minutes", "hours", "days"]);
+
+// ../types/dist/pipeline-analytics.schema.js
+import { z as z48 } from "zod";
+var PeriodSchema = z48.object({
+  since: z48.string(),
+  until: z48.string()
+});
+var PipelineAnalyticsQuerySchema = z48.object({
+  boardId: z48.string().uuid().optional(),
+  since: z48.string().datetime({ offset: true }).optional(),
+  until: z48.string().datetime({ offset: true }).optional()
+});
+var PipelineAnalyticsResolutionQuerySchema = PipelineAnalyticsQuerySchema.extend({
+  resolution: z48.enum(["auto", "minutes", "hours", "days"]).optional()
+});
+var RunsQuerySchema = z48.object({
+  boardId: z48.string().uuid().optional(),
+  limit: z48.coerce.number().optional().default(10)
+});
+var SessionsQuerySchema = z48.object({
+  boardId: z48.string().uuid().optional(),
+  since: z48.string().datetime({ offset: true }).optional(),
+  limit: z48.coerce.number().optional().default(20)
+});
+var AutonomyResponseSchema = z48.object({
+  total_completed: z48.number(),
+  fully_autonomous: z48.number(),
+  human_assisted: z48.number(),
+  human_only: z48.number(),
+  autonomy_rate: z48.number(),
+  period: PeriodSchema
+});
+var RunSchema = z48.object({
+  started_at: z48.string(),
+  ended_at: z48.string(),
+  tickets_entered: z48.number(),
+  tickets_completed: z48.number(),
+  tickets_escalated: z48.number(),
+  duration_minutes: z48.number()
+});
+var RunsResponseSchema = z48.object({
+  runs: z48.array(RunSchema)
+});
+var SessionSchema = z48.object({
+  session_id: z48.string(),
+  started_at: z48.string(),
+  last_activity_at: z48.string(),
+  action_count: z48.number()
+});
+var SessionsResponseSchema = z48.object({
+  sessions: z48.array(SessionSchema)
+});
+var ThroughputBucketSchema = z48.object({
+  timestamp: z48.string(),
+  autonomous: z48.number(),
+  human_assisted: z48.number(),
+  human_only: z48.number(),
+  escalated: z48.number()
+});
+var ThroughputResponseSchema = z48.object({
+  buckets: z48.array(ThroughputBucketSchema),
+  time_unit: TimeUnitSchema,
+  period: PeriodSchema
+});
+
+// ../types/dist/ticket-transition.schema.js
+import { z as z49 } from "zod";
+var TransitionQuerySchema = z49.object({
+  limit: z49.coerce.number().int().min(1).max(100).default(20)
+});
+var TicketTransitionSchema = z49.object({
+  id: z49.string().uuid(),
+  project_id: z49.string().uuid(),
+  board_id: z49.string().uuid(),
+  ticket_id: z49.string().uuid(),
+  from_column: z49.string().uuid().nullable(),
+  to_column: z49.string().uuid(),
+  moved_by: z49.string().uuid().nullable(),
+  handoff: z49.record(z49.string(), z49.unknown()).nullable().default(null),
+  created_at: z49.string().datetime({ offset: true })
+});
+var TicketTransitionWithColumnsSchema = TicketTransitionSchema.extend({
+  from_column_name: z49.string().nullable().optional(),
+  to_column_name: z49.string().nullable().optional()
+});
+
+// ../types/dist/pipeline-context.schema.js
+import { z as z50 } from "zod";
+var AdvisorConfigSchema = z50.object({
+  enabled: z50.boolean(),
+  max_invocations: z50.number().int().positive().optional(),
+  model: z50.string().optional()
+});
+var ModelRoutingSchema = z50.object({
+  initial: z50.string(),
+  escalation: z50.array(z50.string()).min(1),
+  escalate_after: z50.number().int().positive().optional()
+});
+var StuckDetectionConfigSchema = z50.object({
+  enabled: z50.boolean(),
+  first_check: z50.number().int().positive().optional(),
+  interval: z50.number().int().positive().optional()
+});
+var AgentConfigSchema = z50.object({
+  execution_mode: z50.enum(["kant_loop", "cron_poll", "manual"]).optional(),
+  provider: z50.string().optional(),
+  // Column-level provider override (e.g. 'claude', 'codex')
+  model_preference: z50.string().optional(),
+  max_iterations: z50.number().int().positive().optional(),
+  max_budget_usd: z50.number().positive().nullable().optional(),
+  concurrency: z50.number().int().positive().optional(),
+  gutter_threshold: z50.number().int().positive().optional(),
+  poll_interval_seconds: z50.number().int().positive().optional(),
+  worktree: z50.object({
+    enabled: z50.boolean(),
+    path_pattern: z50.string().optional(),
+    // legacy — still accepted, ignored by orchestrator
+    on_move: z50.enum(["keep", "merge", "cleanup"]).optional(),
+    on_done: z50.enum(["pr", "merge", "cleanup"]).optional(),
+    integration_branch: z50.string().optional()
+  }).optional(),
+  invocation_tier: z50.enum(["auto", "light", "heavy"]).optional(),
+  run_memory: z50.boolean().optional(),
+  lookahead_column_id: z50.string().uuid().optional(),
+  advisor: AdvisorConfigSchema.optional(),
+  checkpoint: z50.boolean().optional(),
+  model_routing: ModelRoutingSchema.optional(),
+  builtin_tools: z50.string().optional(),
+  // Value for --tools flag: space-separated list, '' to strip all
+  allowed_tools: z50.array(z50.string()).optional(),
+  disallowed_tools: z50.array(z50.string()).optional(),
+  stuck_detection: StuckDetectionConfigSchema.optional(),
+  extensions: z50.record(z50.string(), z50.unknown()).optional()
+}).strict();
+var TicketFingerprintSchema = z50.object({
+  column_id: z50.string().uuid().nullable(),
+  updated_at: z50.string().datetime({ offset: true }),
+  comment_count: z50.number(),
+  signal_count: z50.number(),
+  field_value_count: z50.number()
+});
+var DebtItemSchema = z50.object({
+  type: z50.enum(["dropped_criterion", "missing_test", "missing_functionality", "unmet_requirement", "waived_gate"]),
+  description: z50.string(),
+  severity: z50.enum(["high", "medium", "low"]),
+  source_column: z50.string().optional()
+});
+var LoopCheckpointSchema = z50.object({
+  run_id: z50.string().uuid(),
+  column_id: z50.string().uuid(),
+  iteration: z50.number().int().nonnegative(),
+  gutter_count: z50.number().int().nonnegative(),
+  advisor_invocations: z50.number().int().nonnegative(),
+  model_tier: z50.string(),
+  last_fingerprint: TicketFingerprintSchema.optional(),
+  worktree_name: z50.string().optional(),
+  updated_at: z50.string().datetime({ offset: true })
+});
+var PipelineContextBoardScopeSchema = z50.object({
+  scope: z50.literal("board"),
+  board: z50.object({
+    id: z50.string().uuid(),
+    name: z50.string()
+  }),
+  backlog_ticket_count: z50.number().int(),
+  columns: z50.array(z50.object({
+    id: z50.string().uuid(),
+    name: z50.string(),
+    type: z50.string(),
+    position: z50.number().int(),
+    wip_limit: z50.number().int().nullable(),
+    goal: z50.string().nullable().optional(),
+    ticket_count: z50.number().int(),
+    has_prompt: z50.boolean(),
+    constraint_count: z50.number().int().nonnegative().optional()
+  })),
+  circuit_breaker: z50.object({
+    threshold: z50.number().int().nullable(),
+    target_column_id: z50.string().uuid().nullable()
+  }).nullable(),
+  tool_prefix: z50.string(),
+  board_constraint_count: z50.number().int().nonnegative().optional()
+});
+var PipelineContextColumnScopeSchema = z50.object({
+  scope: z50.literal("column"),
+  column: z50.object({
+    id: z50.string().uuid(),
+    name: z50.string(),
+    goal: z50.string().nullable().optional()
+  }),
+  prompt_document: z50.object({
+    id: z50.string().uuid(),
+    title: z50.string(),
+    content: z50.string()
+  }).nullable().optional(),
+  agent_config: z50.record(z50.string(), z50.unknown()).nullable().optional(),
+  tickets: z50.array(z50.object({
+    id: z50.string().uuid(),
+    ticket_number: z50.number().int(),
+    title: z50.string(),
+    assignee_name: z50.string().nullable(),
+    backward_transitions: z50.number().int().optional()
+  })),
+  transition_rules: z50.string().nullable(),
+  signals: z50.array(z50.string()),
+  field_definitions: z50.array(z50.object({
+    id: z50.string().uuid(),
+    name: z50.string(),
+    type: z50.string()
+  })),
+  tool_prefix: z50.string(),
+  firing_constraints: z50.array(z50.object({
+    id: z50.string().uuid(),
+    name: z50.string(),
+    enabled: z50.boolean(),
+    subject_type: FiringConstraintSubjectTypeSchema,
+    subject_ref: z50.string(),
+    operator: FiringConstraintOperatorSchema,
+    value: z50.unknown(),
+    scope: z50.string(),
+    notify: z50.boolean(),
+    column_id: z50.string().uuid().nullable()
+  })).optional()
+});
+var PipelineContextTicketScopeSchema = z50.object({
+  scope: z50.literal("ticket"),
+  ticket: z50.object({
+    id: z50.string().uuid(),
+    ticket_number: z50.number().int(),
+    title: z50.string(),
+    description: z50.string().nullable(),
+    backward_transitions: z50.number().int(),
+    assignee: z50.object({
+      id: z50.string().uuid(),
+      name: z50.string()
+    }).nullable(),
+    column: z50.object({
+      id: z50.string().uuid(),
+      name: z50.string(),
+      type: z50.string()
+    }).nullable()
+  }),
+  field_values: z50.array(z50.object({
+    field_name: z50.string(),
+    value: z50.unknown()
+  })),
+  transitions: z50.array(z50.object({
+    from: z50.string().nullable(),
+    to: z50.string(),
+    handoff: z50.record(z50.string(), z50.unknown()).nullable(),
+    timestamp: z50.string()
+  })),
+  comments: z50.array(z50.object({
+    author: z50.string(),
+    body: z50.string(),
+    created_at: z50.string()
+  })),
+  ticket_links: z50.array(z50.object({
+    direction: z50.enum(["outward", "inward"]),
+    link_type: z50.enum(["blocks", "relates_to", "duplicates"]),
+    ticket_id: z50.string().uuid(),
+    ticket_number: z50.number().int(),
+    title: z50.string(),
+    column_name: z50.string().nullable(),
+    resolved: z50.boolean()
+  })),
+  parent: z50.object({
+    id: z50.string().uuid(),
+    ticket_number: z50.number().int(),
+    title: z50.string()
+  }).nullable(),
+  children: z50.array(z50.object({
+    id: z50.string().uuid(),
+    ticket_number: z50.number().int(),
+    title: z50.string(),
+    column_name: z50.string().nullable()
+  })),
+  signals: z50.array(z50.string()),
+  linked_documents: z50.array(z50.object({
+    id: z50.string().uuid(),
+    title: z50.string(),
+    content: z50.string().optional(),
+    truncated: z50.boolean().optional()
+  })),
+  transition_rules: z50.string().nullable(),
+  dependency_requirements: z50.string(),
+  tool_prefix: z50.string()
+});
+var PipelineContextResponseSchema = z50.discriminatedUnion("scope", [
+  PipelineContextBoardScopeSchema,
+  PipelineContextColumnScopeSchema,
+  PipelineContextTicketScopeSchema
+]);
+
+// ../types/dist/gate.schema.js
+import { z as z51 } from "zod";
+var GateResultSchema = z51.object({
+  name: z51.string(),
+  passed: z51.boolean(),
+  required: z51.boolean(),
+  duration_ms: z51.number().int().nonnegative(),
+  output: z51.string().max(1048576),
+  stderr: z51.string(),
+  exit_code: z51.number().int().min(0).max(255),
+  timed_out: z51.boolean()
+});
+var GateDeltaSchema = z51.enum(["improved", "same", "regressed", "first_check"]);
+var GateSnapshotSchema = z51.object({
+  timestamp: z51.string().datetime({ offset: true }),
+  iteration: z51.number().int().nonnegative(),
+  results: z51.array(GateResultSchema),
+  all_required_passed: z51.boolean(),
+  delta_from_previous: GateDeltaSchema
+});
+var GateDefinitionSchema = z51.object({
+  name: z51.string().min(1),
+  run: z51.string().min(1),
+  required: z51.boolean().default(true),
+  timeout: z51.string().regex(/^\d+(s|m)$/, 'Must be format like "60s" or "5m"').optional()
+});
+var ColumnGateOverrideSchema = z51.object({
+  extend: z51.boolean().default(true),
+  gates: z51.array(GateDefinitionSchema).default([])
+});
+var BudgetConfigSchema = z51.object({
+  max_input_tokens: z51.number().int().positive(),
+  max_output_tokens: z51.number().int().positive(),
+  warn_pct: z51.number().int().min(1).max(100).default(75)
+});
+var PricingEntrySchema = z51.object({
+  input_per_mtok: z51.number().nonnegative(),
+  output_per_mtok: z51.number().nonnegative()
+});
+var GateSettingsSchema = z51.object({
+  cwd: z51.string().optional(),
+  env: z51.record(z51.string(), z51.string()).optional(),
+  total_timeout: z51.string().optional(),
+  budget: BudgetConfigSchema.optional(),
+  pricing: z51.record(z51.string(), PricingEntrySchema).optional()
+});
+var GateConfigSchema = z51.object({
+  default: z51.array(GateDefinitionSchema),
+  columns: z51.record(z51.string(), ColumnGateOverrideSchema).optional(),
+  settings: GateSettingsSchema.optional()
+});
+var VerdictFindingSchema = z51.object({
+  severity: z51.enum(["blocker", "warning", "nit"]),
+  file: z51.string().optional(),
+  line: z51.number().int().positive().optional(),
+  description: z51.string()
+});
+var VerdictSchema = z51.object({
+  decision: z51.enum(["approve", "reject"]),
+  summary: z51.string(),
+  findings: z51.array(VerdictFindingSchema)
+});
+
+// src/lib/gate-config.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var VALID_BRANCH_RE = /^[a-zA-Z0-9][a-zA-Z0-9._\-/]*$/;
+function assertNoPrototypePollutionKeys(value, depth = 0) {
+  if (depth > 20 || value === null || typeof value !== "object") return;
+  for (const key of Object.keys(value)) {
+    if (DANGEROUS_KEYS.has(key)) {
+      throw new Error(`Unsafe key "${key}" detected in YAML input`);
+    }
+    assertNoPrototypePollutionKeys(value[key], depth + 1);
+  }
+}
+function parseGateConfig(yamlContent) {
+  const raw = load(yamlContent, { schema: JSON_SCHEMA });
+  assertNoPrototypePollutionKeys(raw);
+  return GateConfigSchema.parse(raw);
+}
+function resolveGatesForColumn(config, columnName) {
+  const lowerName = columnName.toLowerCase();
+  const overrideKey = config.columns ? Object.keys(config.columns).find((k) => k.toLowerCase() === lowerName) : void 0;
+  const override = overrideKey ? config.columns[overrideKey] : void 0;
+  if (!override) {
+    return [...config.default];
+  }
+  if (!override.extend) {
+    if (override.gates.length === 0) {
+      console.error(`  [warn] Column "${columnName}" has extend:false with no gates \u2014 all gate enforcement disabled for this column`);
+    }
+    return [...override.gates];
+  }
+  const overrideNames = new Set(override.gates.map((g) => g.name));
+  const merged = config.default.filter((g) => !overrideNames.has(g.name));
+  return [...merged, ...override.gates];
+}
+var DEFAULT_TIMEOUT_MS = 6e4;
+function parseTimeout(timeout) {
+  if (!timeout) return DEFAULT_TIMEOUT_MS;
+  const match = timeout.match(/^(\d+)(s|m)$/);
+  if (!match) return DEFAULT_TIMEOUT_MS;
+  const value = parseInt(match[1], 10);
+  if (value <= 0) return DEFAULT_TIMEOUT_MS;
+  return match[2] === "m" ? value * 6e4 : value * 1e3;
+}
+
+export {
+  LoopCheckpointSchema,
+  VerdictSchema,
+  VALID_BRANCH_RE,
+  parseGateConfig,
+  resolveGatesForColumn,
+  parseTimeout
+};
+//# sourceMappingURL=chunk-MN4H5NSU.js.map