kantban-cli 0.1.7 → 0.1.10

package/dist/chunk-ZCUIGFSP.js

@@ -0,0 +1,4111 @@
+// src/lib/stuck-detector.ts
+import { z } from "zod";
+
+// src/lib/parse-utils.ts
+function parseJsonFromLlmOutput(raw) {
+  try {
+    return JSON.parse(raw.trim());
+  } catch {
+  }
+  const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenceMatch?.[1]) {
+    const fenced = fenceMatch[1].trim();
+    try {
+      return JSON.parse(fenced);
+    } catch {
+    }
+  }
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < raw.length; j++) {
+      const ch = raw[j];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\" && inString) {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+      if (depth === 0) {
+        const candidate = raw.slice(i, j + 1);
+        try {
+          return JSON.parse(candidate);
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  throw new Error(`Invalid JSON in LLM output: ${raw.slice(0, 120)}`);
+}
+
+// src/lib/stuck-detector.ts
+function shouldCheckStuckDetection(config, iteration) {
+  if (!config.enabled) return false;
+  const firstCheck = config.firstCheck ?? 3;
+  const interval = config.interval ?? 2;
+  if (interval <= 0) return iteration === firstCheck;
+  if (iteration < firstCheck) return false;
+  if (iteration === firstCheck) return true;
+  return (iteration - firstCheck) % interval === 0;
+}
+function composeStuckDetectionPrompt(input) {
+  const commentLines = input.recentComments.length > 0 ? input.recentComments.map((c) => `  [${c.author}] ${c.body.slice(0, 200)}`).join("\n") : "  (no comments)";
+  return `You are a pipeline trajectory classifier. Analyze recent agent activity and classify the trajectory.
+
+Ticket: #${String(input.ticketNumber)} "${input.ticketTitle}"
+Column: ${input.columnName}
+Iteration: ${String(input.iteration)} of ${String(input.maxIterations)}
+
+Recent iteration comments:
+${commentLines}
+
+Classify as one of:
+- "progressing" \u2014 each iteration makes distinct forward progress (new code, new tests, new fields set)
+- "spinning" \u2014 agent is active but repeating similar actions without advancing (same error, same approach retried, output duplicated)
+- "blocked" \u2014 agent cannot make progress due to external dependency, missing information, or fundamental task issue
+
+Respond with ONLY a JSON object:
+{"status": "progressing|spinning|blocked", "confidence": 0.0-1.0, "evidence": "one sentence"}`;
+}
+var StuckDetectionResponseSchema = z.object({
+  status: z.enum(["progressing", "spinning", "blocked"]),
+  confidence: z.number().min(0).max(1),
+  evidence: z.string()
+});
+function parseStuckDetectionResponse(raw) {
+  let parsed;
+  try {
+    parsed = parseJsonFromLlmOutput(raw);
+  } catch (err) {
+    throw new Error(`StuckDetectionResponse: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (parsed && typeof parsed === "object" && "confidence" in parsed) {
+    const p = parsed;
+    if (typeof p.confidence === "number") {
+      p.confidence = Math.min(1, Math.max(0, p.confidence));
+    }
+  }
+  const result = StuckDetectionResponseSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`StuckDetectionResponse: validation failed \u2014 ${result.error.message}`);
+  }
+  return result.data;
+}
+function classifyTrajectory(snapshots) {
+  if (snapshots.length === 0) {
+    return { status: "progressing", evidence: "no data", confidence: 0.5 };
+  }
+  const recent = snapshots.slice(-3);
+  const deltas = recent.map((s) => s.delta_from_previous);
+  const meaningful = deltas.filter((d) => d !== "first_check");
+  if (meaningful.length === 0) {
+    return { status: "progressing", evidence: "only initial checks", confidence: 0.5 };
+  }
+  if (meaningful.every((d) => d === "same")) {
+    return { status: "spinning", evidence: "identical gate results", confidence: 1 };
+  }
+  if (meaningful.every((d) => d === "regressed" || d === "same")) {
+    return { status: "regressing", evidence: "gate results degrading", confidence: 1 };
+  }
+  if (meaningful.some((d) => d === "improved")) {
+    const lastMeaningful = meaningful[meaningful.length - 1];
+    if (lastMeaningful === "improved") {
+      return { status: "progressing", evidence: "gate results improving", confidence: 1 };
+    }
+  }
+  if (meaningful.some((d) => d === "improved") && meaningful.some((d) => d === "regressed")) {
+    return { status: "spinning", evidence: "oscillating gate results", confidence: 1 };
+  }
+  if (meaningful.some((d) => d === "improved")) {
+    return { status: "spinning", evidence: "stale improvement \u2014 no recent progress", confidence: 0.8 };
+  }
+  return { status: "spinning", evidence: "no improvement detected", confidence: 1 };
+}
+
+// src/lib/gate-config.ts
+import { load, JSON_SCHEMA } from "js-yaml";
+
+// ../types/dist/api-response.js
+import { z as z2 } from "zod";
+var ApiErrorSchema = z2.object({
+  success: z2.literal(false),
+  error: z2.object({ code: z2.string(), message: z2.string() })
+});
+
+// ../types/dist/common.js
+import { z as z3 } from "zod";
+var IdSchema = z3.string().uuid();
+var SortOrderSchema = z3.enum(["asc", "desc"]);
+var PaginationParamsSchema = z3.object({
+  page: z3.coerce.number().int().min(1).default(1),
+  limit: z3.coerce.number().int().min(1).max(100).default(20),
+  sort_by: z3.string().optional(),
+  sort_order: SortOrderSchema.default("asc")
+});
+var TimestampsSchema = z3.object({
+  created_at: z3.string().datetime({ offset: true }),
+  updated_at: z3.string().datetime({ offset: true })
+});
+
+// ../types/dist/user.schema.js
+import { z as z4 } from "zod";
+var UserProfileSchema = z4.object({
+  id: z4.string().uuid(),
+  display_name: z4.string().min(1),
+  avatar_url: z4.string().url().nullable(),
+  created_at: z4.string().datetime({ offset: true }),
+  updated_at: z4.string().datetime({ offset: true })
+});
+var CreateUserProfileSchema = z4.object({
+  display_name: z4.string().min(1),
+  avatar_url: z4.string().url().nullable().optional()
+});
+var UpdateUserProfileSchema = z4.object({
+  display_name: z4.string().min(1).optional(),
+  avatar_url: z4.string().url().nullable().optional()
+});
+
+// ../types/dist/project.schema.js
+import { z as z5 } 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 = z5.enum(["owner", "admin", "editor", "viewer"]);
+var ProjectSchema = z5.object({
+  id: z5.string().uuid(),
+  name: z5.string().min(1),
+  owner_id: z5.string().uuid(),
+  icon: z5.string().nullable().default(null),
+  color: z5.string().nullable().default(null),
+  ticket_prefix: z5.string().regex(/^[A-Z]{2,10}$/),
+  ticket_counter: z5.number().int().nonnegative(),
+  created_at: z5.string().datetime({ offset: true }),
+  updated_at: z5.string().datetime({ offset: true })
+});
+var ProjectWithRoleSchema = ProjectSchema.extend({
+  role: ProjectRoleSchema
+});
+var CreateProjectSchema = z5.object({
+  name: z5.string().trim().min(1).max(100),
+  ticket_prefix: z5.string().regex(/^[A-Z]{2,10}$/)
+});
+var IconSchema = z5.string().min(1).refine((val) => val.length <= 3 || val.includes("/") || val.includes("."), "Must be 1-3 character initials or a storage path");
+var UpdateProjectSchema = z5.object({
+  name: z5.string().trim().min(1).max(100).optional(),
+  icon: IconSchema.nullable().optional(),
+  color: z5.enum(PALETTE_KEYS).nullable().optional(),
+  ticket_prefix: z5.string().regex(/^[A-Z]{2,10}$/).optional()
+});
+var DeleteProjectPreviewSchema = z5.object({
+  boards: z5.number().int().nonnegative(),
+  tickets: z5.number().int().nonnegative(),
+  documents: z5.number().int().nonnegative(),
+  doc_spaces: z5.number().int().nonnegative(),
+  fields: z5.number().int().nonnegative(),
+  members: z5.number().int().nonnegative(),
+  conversations: z5.number().int().nonnegative()
+});
+
+// ../types/dist/project-member.schema.js
+import { z as z6 } from "zod";
+var ProjectMemberSchema = z6.object({
+  id: z6.string().uuid(),
+  project_id: z6.string().uuid(),
+  user_id: z6.string().uuid(),
+  role: ProjectRoleSchema,
+  created_at: z6.string().datetime({ offset: true }),
+  updated_at: z6.string().datetime({ offset: true })
+});
+var ProjectMemberWithProfileSchema = ProjectMemberSchema.extend({
+  user: UserProfileSchema
+});
+var UpdateProjectMemberSchema = z6.object({
+  role: z6.enum(["admin", "editor", "viewer"])
+});
+
+// ../types/dist/project-invitation.schema.js
+import { z as z7 } from "zod";
+var InvitationStatusSchema = z7.enum(["pending", "accepted", "declined", "revoked"]);
+var ProjectInvitationSchema = z7.object({
+  id: z7.string().uuid(),
+  project_id: z7.string().uuid(),
+  invited_by: z7.string().uuid(),
+  email: z7.string().email(),
+  role: z7.enum(["admin", "editor", "viewer"]),
+  token: z7.string(),
+  status: InvitationStatusSchema,
+  expires_at: z7.string().datetime({ offset: true }),
+  created_at: z7.string().datetime({ offset: true }),
+  updated_at: z7.string().datetime({ offset: true })
+});
+var ProjectInvitationWithInviterSchema = ProjectInvitationSchema.extend({
+  inviter: UserProfileSchema
+});
+var CreateProjectInvitationSchema = z7.object({
+  email: z7.string().email(),
+  role: z7.enum(["admin", "editor", "viewer"]).default("editor")
+});
+
+// ../types/dist/board.schema.js
+import { z as z9 } from "zod";
+
+// ../types/dist/board-member.schema.js
+import { z as z8 } from "zod";
+var BoardRoleSchema = z8.enum(["owner", "admin", "editor", "viewer"]);
+var BoardMemberSchema = z8.object({
+  id: z8.string().uuid(),
+  board_id: z8.string().uuid(),
+  user_id: z8.string().uuid(),
+  role: BoardRoleSchema,
+  created_at: z8.string().datetime({ offset: true }),
+  updated_at: z8.string().datetime({ offset: true })
+});
+var BoardMemberWithProfileSchema = BoardMemberSchema.extend({
+  user: UserProfileSchema
+});
+var UpdateBoardMemberSchema = z8.object({
+  role: z8.enum(["admin", "editor", "viewer"])
+});
+var AddBoardMemberSchema = z8.object({
+  user_id: z8.string().uuid(),
+  role: z8.enum(["admin", "editor", "viewer"])
+});
+
+// ../types/dist/board.schema.js
+var BoardVisibilitySchema = z9.enum(["public", "private"]);
+var BoardSchema = z9.object({
+  id: z9.string().uuid(),
+  project_id: z9.string().uuid(),
+  name: z9.string().min(1),
+  visibility: BoardVisibilitySchema,
+  icon: z9.string().nullable().default(null),
+  color: z9.string().nullable().default(null),
+  circuit_breaker_threshold: z9.number().int().positive().nullable().default(null),
+  circuit_breaker_target_id: z9.string().uuid().nullable().default(null),
+  created_at: z9.string().datetime({ offset: true }),
+  updated_at: z9.string().datetime({ offset: true })
+});
+var BoardWithRoleSchema = BoardSchema.extend({
+  role: BoardRoleSchema
+});
+var CreateBoardSchema = z9.object({
+  name: z9.string().min(1).max(100),
+  create_default_columns: z9.boolean().optional().default(false),
+  visibility: BoardVisibilitySchema.optional().default("private")
+});
+var IconSchema2 = z9.string().min(1).refine((val) => val.length <= 3 || val.includes("/") || val.includes("."), "Must be 1-3 character initials or a storage path");
+var UpdateBoardSchema = z9.object({
+  name: z9.string().min(1).max(100).optional(),
+  visibility: BoardVisibilitySchema.optional(),
+  icon: IconSchema2.nullable().optional(),
+  color: z9.enum(PALETTE_KEYS).nullable().optional(),
+  circuit_breaker_threshold: z9.number().int().positive().nullable().optional(),
+  circuit_breaker_target_id: z9.string().uuid().nullable().optional()
+});
+var TicketActionSchema = z9.enum(["move_to_backlog", "archive", "delete"]);
+var DeleteBoardBodySchema = z9.object({
+  ticket_action: TicketActionSchema.default("move_to_backlog")
+});
+var DeleteBoardPreviewSchema = z9.object({
+  tickets: z9.number().int().nonnegative(),
+  columns: z9.number().int().nonnegative(),
+  transition_rules: z9.number().int().nonnegative()
+});
+
+// ../types/dist/column.schema.js
+import { z as z10 } from "zod";
+var ColumnTypeSchema = z10.enum(["start", "in_progress", "done", "default", "evaluator"]);
+var ArchiveModeSchema = z10.enum(["off", "immediate", "delayed", "manual"]);
+var ColumnSchema = z10.object({
+  id: z10.string().uuid(),
+  board_id: z10.string().uuid(),
+  name: z10.string().min(1),
+  color: z10.string(),
+  position: z10.number().int(),
+  description: z10.string().nullable(),
+  column_type: ColumnTypeSchema,
+  wip_limit: z10.number().int().nullable(),
+  default_assignee_id: z10.string().uuid().nullable(),
+  archive_mode: ArchiveModeSchema.default("off"),
+  archive_delay_hours: z10.number().positive().nullable().default(null),
+  archive_overflow_limit: z10.number().int().positive().nullable().default(null),
+  prompt_document_id: z10.string().uuid().nullable().default(null),
+  goal: z10.string().nullable().default(null),
+  agent_config: z10.record(z10.string(), z10.unknown()).nullable().default(null),
+  created_at: z10.string().datetime({ offset: true }),
+  updated_at: z10.string().datetime({ offset: true })
+});
+var CreateColumnSchema = z10.object({
+  name: z10.string().min(1).max(100),
+  color: z10.string().optional()
+});
+var UpdateColumnSchema = z10.object({
+  name: z10.string().min(1).max(100).optional(),
+  color: z10.string().optional(),
+  description: z10.string().nullable().optional(),
+  column_type: ColumnTypeSchema.optional(),
+  wip_limit: z10.number().int().nullable().optional(),
+  default_assignee_id: z10.string().uuid().nullable().optional(),
+  archive_mode: ArchiveModeSchema.optional(),
+  archive_delay_hours: z10.number().positive().nullable().optional(),
+  archive_overflow_limit: z10.number().int().positive().nullable().optional(),
+  prompt_document_id: z10.string().uuid().nullable().optional(),
+  goal: z10.string().max(1e3).nullable().optional(),
+  agent_config: z10.record(z10.string(), z10.unknown()).nullable().optional()
+}).superRefine((data, ctx) => {
+  if (data.archive_mode === "delayed" && data.archive_delay_hours == null) {
+    ctx.addIssue({
+      code: z10.ZodIssueCode.custom,
+      message: "archive_delay_hours is required when archive_mode is delayed",
+      path: ["archive_delay_hours"]
+    });
+  }
+});
+var ReorderColumnsSchema = z10.array(z10.object({
+  id: z10.string().uuid(),
+  position: z10.number().int().nonnegative()
+}));
+var DeleteColumnBodySchema = z10.object({
+  ticket_action: TicketActionSchema.default("move_to_backlog")
+});
+var DeleteColumnPreviewSchema = z10.object({
+  tickets: z10.number().int().nonnegative(),
+  transition_rules_broken: z10.number().int().nonnegative(),
+  field_requirements_broken: z10.number().int().nonnegative()
+});
+
+// ../types/dist/ticket.schema.js
+import { z as z11 } from "zod";
+var TicketSchema = z11.object({
+  id: z11.string().uuid(),
+  board_id: z11.string().uuid().nullable(),
+  column_id: z11.string().uuid().nullable(),
+  project_id: z11.string().uuid(),
+  ticket_number: z11.number().int().positive(),
+  title: z11.string().min(1).max(500),
+  description: z11.string().max(1e4),
+  position: z11.number().int(),
+  assignee_id: z11.string().uuid().nullable(),
+  reporter_id: z11.string().uuid(),
+  custom_fields: z11.record(z11.string(), z11.unknown()).default({}),
+  created_at: z11.string().datetime({ offset: true }),
+  updated_at: z11.string().datetime({ offset: true }),
+  archived_at: z11.string().datetime({ offset: true }).nullable().default(null),
+  column_entered_at: z11.string().datetime({ offset: true }).nullable().default(null),
+  first_active_at: z11.string().datetime({ offset: true }).nullable().default(null),
+  done_at: z11.string().datetime({ offset: true }).nullable().default(null),
+  backward_transitions: z11.number().int().default(0),
+  parent_id: z11.string().uuid().nullable().default(null)
+});
+var TicketWithProfilesSchema = TicketSchema.extend({
+  assignee: UserProfileSchema.nullable(),
+  reporter: UserProfileSchema
+});
+var CreateTicketSchema = z11.object({
+  board_id: z11.string().uuid().nullable().optional().default(null),
+  column_id: z11.string().uuid().nullable().optional().default(null),
+  title: z11.string().min(1).max(500),
+  description: z11.string().max(1e4).optional(),
+  assignee_id: z11.string().uuid().nullable().optional(),
+  field_values: z11.record(z11.string(), z11.unknown()).optional(),
+  parent_id: z11.string().uuid().nullable().optional()
+});
+var UpdateTicketSchema = z11.object({
+  title: z11.string().min(1).max(500).optional(),
+  description: z11.string().max(1e4).optional(),
+  assignee_id: z11.string().uuid().nullable().optional(),
+  parent_id: z11.string().uuid().nullable().optional()
+});
+var MoveTicketSchema = z11.object({
+  column_id: z11.string().uuid().nullable(),
+  position: z11.number().int().nonnegative(),
+  handoff: z11.record(z11.string(), z11.unknown()).optional(),
+  force: z11.boolean().optional().default(false),
+  field_values: z11.record(z11.string(), z11.unknown()).optional().describe("Map of field name \u2192 value. Names are resolved to field IDs server-side.")
+});
+var MoveToBoardSchema = z11.object({
+  board_id: z11.string().uuid(),
+  column_id: z11.string().uuid()
+});
+var CreateBacklogTicketSchema = z11.object({
+  title: z11.string().min(1).max(500),
+  description: z11.string().max(1e4).optional(),
+  assignee_id: z11.string().uuid().nullable().optional()
+});
+var ReorderTicketsSchema = z11.array(z11.object({
+  id: z11.string().uuid(),
+  column_id: z11.string().uuid().nullable(),
+  position: z11.number().int().nonnegative()
+}));
+var DeleteTicketPreviewSchema = z11.object({
+  comments: z11.number().int().nonnegative(),
+  attachments: z11.number().int().nonnegative()
+});
+
+// ../types/dist/comment.schema.js
+import { z as z12 } from "zod";
+var CommentSchema = z12.object({
+  id: z12.string().uuid(),
+  ticket_id: z12.string().uuid(),
+  author_id: z12.string().uuid(),
+  body: z12.string().min(1),
+  created_at: z12.string().datetime({ offset: true }),
+  updated_at: z12.string().datetime({ offset: true }),
+  pinned: z12.boolean().default(false)
+});
+var CommentWithAuthorSchema = CommentSchema.extend({
+  author: UserProfileSchema
+});
+var CreateCommentSchema = z12.object({
+  body: z12.string().min(1).max(1e4)
+});
+var UpdateCommentSchema = z12.object({
+  body: z12.string().min(1).max(1e4).optional(),
+  pinned: z12.boolean().optional()
+});
+
+// ../types/dist/jobs.schema.js
+import { z as z13 } from "zod";
+var WelcomeEmailJobDataSchema = z13.object({
+  userId: z13.string().uuid(),
+  email: z13.string().email(),
+  displayName: z13.string()
+});
+var InvitationEmailJobDataSchema = z13.object({
+  email: z13.string().email(),
+  projectName: z13.string(),
+  token: z13.string(),
+  role: z13.string(),
+  invitedBy: z13.string().uuid()
+});
+
+// ../types/dist/upload.schema.js
+import { z as z14 } from "zod";
+var UploadResultSchema = z14.object({
+  path: z14.string(),
+  url: z14.string().url().nullable()
+});
+
+// ../types/dist/ticket-attachment.schema.js
+import { z as z15 } from "zod";
+var TicketAttachmentSchema = z15.object({
+  id: z15.string().uuid(),
+  ticket_id: z15.string().uuid(),
+  uploader_id: z15.string().uuid(),
+  storage_path: z15.string().min(1),
+  file_name: z15.string().min(1),
+  mime_type: z15.string().min(1),
+  file_size: z15.number().int().positive(),
+  created_at: z15.string().datetime({ offset: true })
+});
+var TicketAttachmentWithUrlSchema = TicketAttachmentSchema.extend({
+  url: z15.string()
+});
+var CreateTicketAttachmentSchema = z15.object({
+  storage_path: z15.string().min(1),
+  file_name: z15.string().min(1),
+  mime_type: z15.string().min(1),
+  file_size: z15.number().int().positive()
+});
+
+// ../types/dist/board-ws.schema.js
+import { z as z23 } from "zod";
+
+// ../types/dist/field-definition.schema.js
+import { z as z16 } from "zod";
+var FieldTypeSchema = z16.enum([
+  "short_text",
+  "long_text",
+  "rich_text",
+  "number",
+  "date",
+  "single_select",
+  "multi_select",
+  "checkbox",
+  "user",
+  "ticket_link",
+  "document_link",
+  "github_pr"
+]);
+var CreateFieldTypeSchema = z16.enum([
+  "short_text",
+  "long_text",
+  "rich_text",
+  "number",
+  "date",
+  "single_select",
+  "multi_select",
+  "checkbox",
+  "user",
+  "document_link",
+  "github_pr"
+]);
+var SelectOptionSchema = z16.object({
+  id: z16.string().uuid(),
+  label: z16.string().min(1).max(100),
+  color: z16.string()
+});
+var FieldConfigSchema = z16.object({
+  placeholder: z16.string().optional(),
+  max_length: z16.number().int().positive().optional(),
+  regex: z16.string().optional(),
+  min: z16.number().optional(),
+  max: z16.number().optional(),
+  decimals: z16.number().int().min(0).optional(),
+  unit: z16.string().optional(),
+  allow_past: z16.boolean().optional(),
+  allow_time: z16.boolean().optional(),
+  options: z16.array(SelectOptionSchema).optional(),
+  max_selections: z16.number().int().positive().optional(),
+  default_checked: z16.boolean().optional(),
+  scope: z16.enum(["board", "project"]).optional(),
+  show_checks: z16.boolean().optional(),
+  show_reviews: z16.boolean().optional()
+}).default({});
+var FieldDefinitionSchema = z16.object({
+  id: z16.string().uuid(),
+  project_id: z16.string().uuid(),
+  name: z16.string().min(1).max(100),
+  type: FieldTypeSchema,
+  config: FieldConfigSchema,
+  position: z16.number().int(),
+  created_at: z16.string().datetime({ offset: true }),
+  updated_at: z16.string().datetime({ offset: true })
+});
+var CreateFieldDefinitionSchema = z16.object({
+  name: z16.string().min(1).max(100),
+  type: FieldTypeSchema,
+  config: FieldConfigSchema.optional()
+});
+var UpdateFieldDefinitionSchema = z16.object({
+  name: z16.string().min(1).max(100).optional(),
+  config: FieldConfigSchema.optional(),
+  position: z16.number().int().optional()
+});
+var ReorderFieldDefinitionsSchema = z16.object({
+  items: z16.array(z16.object({
+    id: z16.string().uuid(),
+    position: z16.number().int()
+  }))
+});
+var DeleteFieldDefinitionPreviewSchema = z16.object({
+  tickets_affected: z16.number().int().nonnegative(),
+  field_values: z16.number().int().nonnegative(),
+  board_overrides: z16.number().int().nonnegative()
+});
+
+// ../types/dist/field-override.schema.js
+import { z as z17 } from "zod";
+var BoardFieldOverrideSchema = z17.object({
+  id: z17.string().uuid(),
+  board_id: z17.string().uuid(),
+  field_id: z17.string().uuid(),
+  is_enabled: z17.boolean(),
+  is_required: z17.boolean(),
+  show_on_card: z17.boolean(),
+  position: z17.number().int().nullable(),
+  default_value: z17.unknown().nullable(),
+  extra_options: z17.array(SelectOptionSchema).nullable(),
+  created_at: z17.string().datetime({ offset: true }),
+  updated_at: z17.string().datetime({ offset: true })
+});
+var UpsertFieldOverrideSchema = z17.object({
+  is_enabled: z17.boolean().optional(),
+  is_required: z17.boolean().optional(),
+  show_on_card: z17.boolean().optional(),
+  position: z17.number().int().nullable().optional(),
+  default_value: z17.unknown().nullable().optional(),
+  extra_options: z17.array(SelectOptionSchema).nullable().optional()
+});
+var MergedFieldSchema = FieldDefinitionSchema.extend({
+  is_enabled: z17.boolean().default(true),
+  is_required: z17.boolean().default(false),
+  show_on_card: z17.boolean().default(false),
+  effective_position: z17.number().int(),
+  default_value: z17.unknown().nullable().default(null),
+  extra_options: z17.array(SelectOptionSchema).default([]),
+  all_options: z17.array(SelectOptionSchema).default([])
+});
+
+// ../types/dist/transition-rule.schema.js
+import { z as z18 } from "zod";
+var TransitionRuleStatusSchema = z18.enum(["active", "broken"]);
+var TransitionRuleSchema = z18.object({
+  id: z18.string().uuid(),
+  board_id: z18.string().uuid(),
+  from_column_id: z18.string().uuid().nullable(),
+  to_column_id: z18.string().uuid().nullable(),
+  from_tombstone_id: z18.string().uuid().nullable(),
+  to_tombstone_id: z18.string().uuid().nullable(),
+  status: TransitionRuleStatusSchema,
+  instruction: z18.string().nullable(),
+  created_at: z18.string().datetime({ offset: true }),
+  updated_at: z18.string().datetime({ offset: true })
+});
+var TransitionRuleWithTombstoneSchema = TransitionRuleSchema.extend({
+  from_tombstone_name: z18.string().nullable().default(null),
+  to_tombstone_name: z18.string().nullable().default(null)
+});
+var BulkUpsertTransitionRulesSchema = z18.object({
+  rules: z18.array(z18.object({
+    from_column_id: z18.string().uuid().nullable(),
+    to_column_id: z18.string().uuid(),
+    instruction: z18.string().nullable().optional()
+  }))
+});
+
+// ../types/dist/signal.schema.js
+import { z as z19 } from "zod";
+var SignalScopeTypeSchema = z19.enum(["project", "board", "column", "ticket"]);
+var SignalSourceSchema = z19.enum(["human", "agent"]);
+var SignalSchema = z19.object({
+  id: z19.string().uuid(),
+  project_id: z19.string().uuid(),
+  scope_type: SignalScopeTypeSchema,
+  scope_id: z19.string().uuid(),
+  content: z19.string().min(1),
+  source: SignalSourceSchema,
+  created_by: z19.string().uuid().nullable(),
+  session_id: z19.string().uuid().nullable(),
+  iteration: z19.number().int().nullable(),
+  created_at: z19.string().datetime({ offset: true }),
+  updated_at: z19.string().datetime({ offset: true })
+});
+var CreateSignalSchema = z19.object({
+  scopeType: SignalScopeTypeSchema,
+  scopeId: z19.string().uuid(),
+  content: z19.string().min(1).max(5e3)
+});
+var UpdateSignalSchema = z19.object({
+  content: z19.string().min(1).max(5e3)
+});
+var PromoteSignalSchema = z19.object({
+  newScopeType: SignalScopeTypeSchema,
+  newScopeId: z19.string().uuid()
+});
+
+// ../types/dist/pipeline-session.schema.js
+import { z as z20 } from "zod";
+var InvocationTypeSchema = z20.enum(["heavy", "light", "advisor", "stuck_detection", "orchestrator"]);
+var ExitReasonSchema = z20.enum(["moved", "stalled", "error", "max_iterations", "stopped", "deleted"]);
+var PipelineSessionSchema = z20.object({
+  id: z20.string().uuid(),
+  project_id: z20.string().uuid(),
+  board_id: z20.string().uuid(),
+  ticket_id: z20.string().uuid().nullable(),
+  column_id: z20.string().uuid().nullable(),
+  run_id: z20.string().min(1).max(128),
+  session_id: z20.string().min(1).max(128),
+  model: z20.string().min(1).max(100),
+  invocation_type: InvocationTypeSchema,
+  iteration: z20.number().int().nullable(),
+  tokens_in: z20.number().int().nonnegative(),
+  tokens_out: z20.number().int().nonnegative(),
+  tool_call_count: z20.number().int().nonnegative(),
+  duration_ms: z20.number().int().nonnegative(),
+  exit_reason: ExitReasonSchema.nullable(),
+  started_at: z20.string().datetime({ offset: true }),
+  ended_at: z20.string().datetime({ offset: true }).nullable(),
+  created_at: z20.string().datetime({ offset: true }),
+  updated_at: z20.string().datetime({ offset: true }).nullable()
+});
+var CreatePipelineSessionSchema = z20.object({
+  project_id: z20.string().uuid(),
+  board_id: z20.string().uuid(),
+  ticket_id: z20.string().uuid().nullable(),
+  column_id: z20.string().uuid().nullable(),
+  run_id: z20.string().min(1).max(128),
+  session_id: z20.string().min(1).max(128),
+  model: z20.string().min(1).max(100),
+  invocation_type: InvocationTypeSchema,
+  iteration: z20.number().int().nullable().optional(),
+  started_at: z20.string().datetime({ offset: true }).optional()
+});
+var UpdatePipelineSessionSchema = z20.object({
+  tokens_in: z20.number().int().nonnegative(),
+  tokens_out: z20.number().int().nonnegative(),
+  tool_call_count: z20.number().int().nonnegative(),
+  duration_ms: z20.number().int().nonnegative(),
+  exit_reason: ExitReasonSchema.nullable(),
+  ended_at: z20.string().datetime({ offset: true })
+});
+var PipelineSessionQuerySchema = z20.object({
+  ticketId: z20.string().uuid().optional(),
+  boardId: z20.string().uuid().optional(),
+  sessionId: z20.string().optional(),
+  limit: z20.coerce.number().int().min(1).max(100).optional().default(50),
+  cursor: z20.string().optional()
+});
+
+// ../types/dist/firing-constraint.schema.js
+import { z as z21 } from "zod";
+var FiringConstraintSubjectTypeSchema = z21.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 = z21.enum(["lt", "lte", "gt", "gte", "eq", "neq"]);
+var FiringConstraintScopeSchema = z21.enum(["column", "ticket"]);
+var FiringConstraintSchema = z21.object({
+  id: z21.string().uuid(),
+  project_id: z21.string().uuid(),
+  board_id: z21.string().uuid(),
+  column_id: z21.string().uuid().nullable(),
+  name: z21.string().min(1).max(200),
+  description: z21.string().nullable(),
+  enabled: z21.boolean(),
+  subject_type: FiringConstraintSubjectTypeSchema,
+  subject_ref: z21.string().nullable(),
+  subject_param: z21.string().nullable(),
+  operator: FiringConstraintOperatorSchema,
+  value: z21.union([z21.number(), z21.string(), z21.boolean()]),
+  scope: FiringConstraintScopeSchema,
+  notify: z21.boolean(),
+  position: z21.number().int(),
+  fail_open: z21.boolean(),
+  system: z21.boolean(),
+  created_at: z21.string().datetime({ offset: true }),
+  updated_at: z21.string().datetime({ offset: true })
+});
+var CreateFiringConstraintSchema = z21.object({
+  column_id: z21.string().uuid().nullable().optional(),
+  name: z21.string().min(1).max(200),
+  description: z21.string().nullable().optional(),
+  subject_type: FiringConstraintSubjectTypeSchema,
+  subject_ref: z21.string().nullable().optional(),
+  subject_param: z21.string().nullable().optional(),
+  operator: FiringConstraintOperatorSchema,
+  value: z21.union([z21.number(), z21.string(), z21.boolean()]),
+  scope: FiringConstraintScopeSchema.default("column"),
+  notify: z21.boolean().default(false),
+  enabled: z21.boolean().default(true),
+  fail_open: z21.boolean().default(false),
+  system: z21.boolean().default(false)
+});
+var UpdateFiringConstraintSchema = z21.object({
+  column_id: z21.string().uuid().nullable().optional(),
+  name: z21.string().min(1).max(200).optional(),
+  description: z21.string().nullable().optional(),
+  enabled: z21.boolean().optional(),
+  subject_type: FiringConstraintSubjectTypeSchema.optional(),
+  subject_ref: z21.string().nullable().optional(),
+  subject_param: z21.string().nullable().optional(),
+  operator: FiringConstraintOperatorSchema.optional(),
+  value: z21.union([z21.number(), z21.string(), z21.boolean()]).optional(),
+  scope: FiringConstraintScopeSchema.optional(),
+  notify: z21.boolean().optional(),
+  position: z21.number().int().optional(),
+  fail_open: z21.boolean().optional()
+});
+var EvaluateFiringConstraintResultSchema = z21.object({
+  constraint_id: z21.string().uuid(),
+  name: z21.string(),
+  column_id: z21.string().uuid().nullable(),
+  passed: z21.boolean(),
+  resolved_value: z21.union([z21.number(), z21.string(), z21.boolean()]).nullable(),
+  threshold: z21.object({
+    operator: z21.string(),
+    value: z21.union([z21.number(), z21.string(), z21.boolean()])
+  }),
+  error: z21.string().optional()
+});
+var EvaluateFiringConstraintsResponseSchema = z21.object({
+  board_id: z21.string().uuid(),
+  results: z21.array(EvaluateFiringConstraintResultSchema),
+  summary: z21.object({
+    total: z21.number().int(),
+    passed: z21.number().int(),
+    failed: z21.number().int(),
+    errors: z21.number().int()
+  })
+});
+
+// ../types/dist/pipeline-event.schema.js
+import { z as z22 } from "zod";
+var PipelineEventLayerSchema = z22.enum([
+  "gate",
+  "advisor",
+  "evaluator",
+  "constraint",
+  "cost",
+  "session",
+  "replanner"
+]);
+var PipelineEventSeveritySchema = z22.enum(["info", "warning", "failure"]);
+var PipelineEventSchema = z22.object({
+  id: z22.string().uuid(),
+  project_id: z22.string().uuid(),
+  board_id: z22.string().uuid(),
+  ticket_id: z22.string().uuid().nullable(),
+  column_id: z22.string().uuid().nullable(),
+  run_id: z22.string().nullable(),
+  session_id: z22.string().nullable(),
+  layer: PipelineEventLayerSchema,
+  event_type: z22.string().min(1).max(100),
+  severity: PipelineEventSeveritySchema,
+  summary: z22.string().min(1).max(1e3),
+  detail: z22.record(z22.unknown()).nullable(),
+  iteration: z22.number().int().nullable(),
+  created_at: z22.string().datetime({ offset: true })
+});
+var CreatePipelineEventSchema = z22.object({
+  board_id: z22.string().uuid(),
+  ticket_id: z22.string().uuid().nullable().optional(),
+  column_id: z22.string().uuid().nullable().optional(),
+  run_id: z22.string().nullable().optional(),
+  session_id: z22.string().nullable().optional(),
+  layer: PipelineEventLayerSchema,
+  event_type: z22.string().min(1).max(100),
+  severity: PipelineEventSeveritySchema,
+  summary: z22.string().min(1).max(1e3),
+  detail: z22.record(z22.unknown()).nullable().optional(),
+  iteration: z22.number().int().nullable().optional()
+});
+var CreatePipelineEventBatchSchema = z22.object({
+  events: z22.array(CreatePipelineEventSchema).min(1).max(100)
+});
+var PipelineEventsQuerySchema = z22.object({
+  boardId: z22.string().uuid(),
+  layer: z22.string().optional().transform((val) => {
+    if (!val)
+      return void 0;
+    const parts = val.split(",").map((s) => s.trim());
+    for (const p of parts) {
+      PipelineEventLayerSchema.parse(p);
+    }
+    return val;
+  }),
+  severity: z22.string().optional().transform((val) => {
+    if (!val)
+      return void 0;
+    const parts = val.split(",").map((s) => s.trim());
+    for (const p of parts) {
+      PipelineEventSeveritySchema.parse(p);
+    }
+    return val;
+  }),
+  ticketId: z22.string().uuid().optional(),
+  columnId: z22.string().uuid().optional(),
+  runId: z22.string().optional(),
+  since: z22.string().datetime({ offset: true }).optional(),
+  until: z22.string().datetime({ offset: true }).optional(),
+  cursor: z22.string().optional(),
+  limit: z22.coerce.number().int().min(1).max(200).default(50)
+});
+var LayerSummarySchema = z22.object({
+  gates: z22.object({
+    total: z22.number(),
+    passed: z22.number(),
+    failed: z22.number(),
+    top_failing_gate: z22.string().nullable(),
+    top_failing_count: z22.number()
+  }),
+  advisor: z22.object({
+    total: z22.number(),
+    by_action: z22.record(z22.number())
+  }),
+  evaluator: z22.object({
+    total: z22.number(),
+    approved: z22.number(),
+    rejected: z22.number(),
+    blocker_count: z22.number()
+  }),
+  constraints: z22.object({
+    total_evaluations: z22.number(),
+    currently_blocked: z22.number(),
+    top_blocking_name: z22.string().nullable(),
+    top_blocking_column: z22.string().nullable()
+  }),
+  cost: z22.object({
+    total_tokens_in: z22.number(),
+    total_tokens_out: z22.number(),
+    max_tokens: z22.number().nullable(),
+    top_ticket_id: z22.string().uuid().nullable(),
+    top_ticket_tokens: z22.number()
+  }),
+  truncated: z22.boolean()
+});
+
+// ../types/dist/board-ws.schema.js
+var WsActorSchema = z23.object({
+  id: z23.string().uuid(),
+  displayName: z23.string()
+}).nullable();
+var WsBoardSubscribeSchema = z23.object({
+  type: z23.literal("board:subscribe"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    projectId: z23.string().uuid()
+  })
+});
+var WsBoardUnsubscribeSchema = z23.object({
+  type: z23.literal("board:unsubscribe"),
+  payload: z23.object({
+    boardId: z23.string().uuid()
+  })
+});
+var pipelineIdString = z23.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
+var WsPipelineStreamClientSchema = z23.object({
+  type: z23.literal("pipeline:stream"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid().nullable(),
+    columnId: z23.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    event: z23.record(z23.unknown())
+  })
+});
+var WsPipelineSessionStartClientSchema = z23.object({
+  type: z23.literal("pipeline:session-start"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid().nullable(),
+    columnId: z23.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    model: z23.string(),
+    invocationType: InvocationTypeSchema,
+    iteration: z23.number().int().nullable()
+  })
+});
+var WsPipelineSessionEndClientSchema = z23.object({
+  type: z23.literal("pipeline:session-end"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    runId: pipelineIdString,
+    exitReason: ExitReasonSchema.nullable(),
+    tokensIn: z23.number().int().nonnegative(),
+    tokensOut: z23.number().int().nonnegative(),
+    toolCallCount: z23.number().int().nonnegative(),
+    durationMs: z23.number().int().nonnegative()
+  })
+});
+var WsPipelineStoppedClientSchema = z23.object({
+  type: z23.literal("pipeline:stopped"),
+  payload: z23.object({
+    boardId: z23.string().uuid()
+  })
+});
+var WsBoardClientEvents = [
+  WsBoardSubscribeSchema,
+  WsBoardUnsubscribeSchema,
+  WsPipelineStreamClientSchema,
+  WsPipelineSessionStartClientSchema,
+  WsPipelineSessionEndClientSchema,
+  WsPipelineStoppedClientSchema
+];
+var WsBoardUpdatedSchema = z23.object({
+  type: z23.literal("board:updated"),
+  payload: z23.object({
+    board: BoardWithRoleSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardDeletedSchema = z23.object({
+  type: z23.literal("board:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBoardSubscribedSchema = z23.object({
+  type: z23.literal("board:subscribed"),
+  payload: z23.object({
+    boardId: z23.string().uuid()
+  })
+});
+var WsBoardUnsubscribedSchema = z23.object({
+  type: z23.literal("board:unsubscribed"),
+  payload: z23.object({
+    boardId: z23.string().uuid()
+  })
+});
+var WsBoardAccessRevokedSchema = z23.object({
+  type: z23.literal("board:access-revoked"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    reason: z23.string()
+  })
+});
+var WsColumnCreatedSchema = z23.object({
+  type: z23.literal("column:created"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    column: ColumnSchema,
+    actor: WsActorSchema
+  })
+});
+var WsColumnUpdatedSchema = z23.object({
+  type: z23.literal("column:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    column: ColumnSchema,
+    actor: WsActorSchema
+  })
+});
+var WsColumnDeletedSchema = z23.object({
+  type: z23.literal("column:deleted"),
+  payload: z23.object({
+    columnId: z23.string().uuid(),
+    ticketAction: z23.enum(["delete", "archive", "move_to_backlog"]),
+    ticketIds: z23.array(z23.string().uuid()),
+    actor: WsActorSchema
+  })
+});
+var WsColumnReorderedSchema = z23.object({
+  type: z23.literal("column:reordered"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    columns: z23.array(z23.object({ id: z23.string().uuid(), position: z23.number().int() })),
+    actor: WsActorSchema
+  })
+});
+var WsTicketCreatedSchema = z23.object({
+  type: z23.literal("ticket:created"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    columnId: z23.string().uuid().nullable(),
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketUpdatedSchema = z23.object({
+  type: z23.literal("ticket:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketDeletedSchema = z23.object({
+  type: z23.literal("ticket:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsTicketMovedSchema = z23.object({
+  type: z23.literal("ticket:moved"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticket: TicketWithProfilesSchema,
+    fromColumnId: z23.string().uuid().nullable(),
+    actor: WsActorSchema
+  })
+});
+var WsTicketReorderedSchema = z23.object({
+  type: z23.literal("ticket:reordered"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    tickets: z23.array(z23.object({
+      id: z23.string().uuid(),
+      columnId: z23.string().uuid().nullable(),
+      position: z23.number().int()
+    })),
+    actor: WsActorSchema
+  })
+});
+var WsTicketArchivedSchema = z23.object({
+  type: z23.literal("ticket:archived"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    archivedAt: z23.string().datetime({ offset: true }),
+    actor: WsActorSchema
+  })
+});
+var WsTicketUnarchivedSchema = z23.object({
+  type: z23.literal("ticket:unarchived"),
+  payload: z23.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsTicketBulkArchivedSchema = z23.object({
+  type: z23.literal("ticket:bulk-archived"),
+  payload: z23.object({
+    columnId: z23.string().uuid(),
+    ticketIds: z23.array(z23.string().uuid()),
+    actor: WsActorSchema
+  })
+});
+var WsCommentCreatedSchema = z23.object({
+  type: z23.literal("comment:created"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    comment: CommentWithAuthorSchema,
+    actor: WsActorSchema
+  })
+});
+var WsCommentUpdatedSchema = z23.object({
+  type: z23.literal("comment:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    comment: CommentWithAuthorSchema,
+    actor: WsActorSchema
+  })
+});
+var WsCommentDeletedSchema = z23.object({
+  type: z23.literal("comment:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    commentId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsAttachmentCreatedSchema = z23.object({
+  type: z23.literal("attachment:created"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    attachment: TicketAttachmentWithUrlSchema,
+    actor: WsActorSchema
+  })
+});
+var WsAttachmentDeletedSchema = z23.object({
+  type: z23.literal("attachment:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid(),
+    attachmentId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsFieldValueUpdatedSchema = z23.object({
+  type: z23.literal("field-value:updated"),
+  payload: z23.object({
+    ticketId: z23.string().uuid(),
+    fieldId: z23.string().uuid(),
+    value: z23.unknown(),
+    customFields: z23.record(z23.string(), z23.unknown()),
+    actor: WsActorSchema
+  })
+});
+var WsFieldValueRemovedSchema = z23.object({
+  type: z23.literal("field-value:removed"),
+  payload: z23.object({
+    ticketId: z23.string().uuid(),
+    fieldId: z23.string().uuid(),
+    customFields: z23.record(z23.string(), z23.unknown()),
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionCreatedSchema = z23.object({
+  type: z23.literal("field-definition:created"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    field: FieldDefinitionSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionUpdatedSchema = z23.object({
+  type: z23.literal("field-definition:updated"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    field: FieldDefinitionSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionDeletedSchema = z23.object({
+  type: z23.literal("field-definition:deleted"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    fieldId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsFieldDefinitionReorderedSchema = z23.object({
+  type: z23.literal("field-definition:reordered"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    fields: z23.array(z23.object({ id: z23.string().uuid(), position: z23.number().int() })),
+    actor: WsActorSchema
+  })
+});
+var WsFieldOverrideUpdatedSchema = z23.object({
+  type: z23.literal("field-override:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    fieldOverride: BoardFieldOverrideSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFieldOverrideDeletedSchema = z23.object({
+  type: z23.literal("field-override:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    fieldId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsTransitionRulesUpdatedSchema = z23.object({
+  type: z23.literal("transition-rules:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    rules: z23.array(TransitionRuleSchema),
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberAddedSchema = z23.object({
+  type: z23.literal("board-member:added"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    member: BoardMemberWithProfileSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberUpdatedSchema = z23.object({
+  type: z23.literal("board-member:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    member: BoardMemberWithProfileSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardMemberRemovedSchema = z23.object({
+  type: z23.literal("board-member:removed"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    userId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketAddedSchema = z23.object({
+  type: z23.literal("backlog:ticket-added"),
+  payload: z23.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketRemovedSchema = z23.object({
+  type: z23.literal("backlog:ticket-removed"),
+  payload: z23.object({
+    ticketId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketUpdatedSchema = z23.object({
+  type: z23.literal("backlog:ticket-updated"),
+  payload: z23.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketArchivedSchema = z23.object({
+  type: z23.literal("backlog:ticket-archived"),
+  payload: z23.object({
+    ticketId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketUnarchivedSchema = z23.object({
+  type: z23.literal("backlog:ticket-unarchived"),
+  payload: z23.object({
+    ticket: TicketWithProfilesSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBacklogTicketsAddedSchema = z23.object({
+  type: z23.literal("backlog:tickets-added"),
+  payload: z23.object({
+    ticketIds: z23.array(z23.string().uuid()),
+    projectId: z23.string().uuid()
+  })
+});
+var WsBoardlistCreatedSchema = z23.object({
+  type: z23.literal("boardlist:created"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    board: BoardSchema,
+    actor: WsActorSchema
+  })
+});
+var WsBoardlistUpdatedSchema = z23.object({
+  type: z23.literal("boardlist:updated"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    board: BoardSchema.partial().extend({ id: z23.string().uuid() }),
+    actor: WsActorSchema
+  })
+});
+var WsBoardlistDeletedSchema = z23.object({
+  type: z23.literal("boardlist:deleted"),
+  payload: z23.object({
+    projectId: z23.string().uuid(),
+    boardId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsSignalCreatedSchema = z23.object({
+  type: z23.literal("signal:created"),
+  payload: z23.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsSignalUpdatedSchema = z23.object({
+  type: z23.literal("signal:updated"),
+  payload: z23.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsSignalDeletedSchema = z23.object({
+  type: z23.literal("signal:deleted"),
+  payload: z23.object({
+    signalId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsSignalPromotedSchema = z23.object({
+  type: z23.literal("signal:promoted"),
+  payload: z23.object({
+    signal: SignalSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintCreatedSchema = z23.object({
+  type: z23.literal("firing_constraint:created"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    constraint: FiringConstraintSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintUpdatedSchema = z23.object({
+  type: z23.literal("firing_constraint:updated"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    constraint: FiringConstraintSchema,
+    actor: WsActorSchema
+  })
+});
+var WsFiringConstraintDeletedSchema = z23.object({
+  type: z23.literal("firing_constraint:deleted"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    constraintId: z23.string().uuid(),
+    actor: WsActorSchema
+  })
+});
+var WsPipelineStreamSchema = z23.object({
+  type: z23.literal("pipeline:stream"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid().nullable(),
+    columnId: z23.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    event: z23.record(z23.unknown())
+  })
+});
+var WsPipelineSessionStartSchema = z23.object({
+  type: z23.literal("pipeline:session-start"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    ticketId: z23.string().uuid().nullable(),
+    columnId: z23.string().uuid().nullable(),
+    runId: pipelineIdString,
+    sessionId: pipelineIdString,
+    model: z23.string(),
+    invocationType: InvocationTypeSchema,
+    iteration: z23.number().int().nullable()
+  })
+});
+var WsPipelineSessionEndSchema = z23.object({
+  type: z23.literal("pipeline:session-end"),
+  payload: z23.object({
+    boardId: z23.string().uuid(),
+    runId: pipelineIdString,
+    exitReason: ExitReasonSchema.nullable(),
+    tokensIn: z23.number().int().nonnegative(),
+    tokensOut: z23.number().int().nonnegative(),
+    toolCallCount: z23.number().int().nonnegative(),
+    durationMs: z23.number().int().nonnegative()
+  })
+});
+var WsPipelineStoppedSchema = z23.object({
+  type: z23.literal("pipeline:stopped"),
+  payload: z23.object({
+    boardId: z23.string().uuid()
+  })
+});
+var WsPipelineEventSchema = z23.object({
+  type: z23.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 z25 } from "zod";
+
+// ../types/dist/call.schema.js
+import { z as z24 } from "zod";
+var CallTypeSchema = z24.enum(["audio", "screen_share"]);
+var CallStatusSchema = z24.enum(["ringing", "active", "ended", "missed"]);
+var UserStatusSchema = z24.enum(["online", "away", "in_call", "dnd", "offline"]);
+var CallSessionSchema = z24.object({
+  id: z24.string().uuid(),
+  project_id: z24.string().uuid(),
+  conversation_id: z24.string().uuid().nullable(),
+  status: CallStatusSchema,
+  created_by: z24.string().uuid(),
+  livekit_room_name: z24.string(),
+  started_at: z24.string().datetime({ offset: true }).nullable(),
+  ended_at: z24.string().datetime({ offset: true }).nullable(),
+  created_at: z24.string().datetime({ offset: true })
+});
+var CallParticipantSchema = z24.object({
+  id: z24.string().uuid(),
+  session_id: z24.string().uuid(),
+  user_id: z24.string().uuid(),
+  joined_at: z24.string().datetime({ offset: true }).nullable(),
+  left_at: z24.string().datetime({ offset: true }).nullable()
+});
+var CallParticipantWithProfileSchema = CallParticipantSchema.extend({
+  user: UserProfileSchema
+});
+var CallSessionWithParticipantsSchema = CallSessionSchema.extend({
+  participants: z24.array(CallParticipantWithProfileSchema),
+  creator: UserProfileSchema
+});
+var StartCallSchema = z24.object({
+  conversationId: z24.string().uuid().optional(),
+  participantIds: z24.array(z24.string().uuid()).min(1).max(4)
+});
+var JoinCallSchema = z24.object({
+  sessionId: z24.string().uuid()
+});
+var CallTokenResponseSchema = z24.object({
+  token: z24.string(),
+  wsUrl: z24.string(),
+  roomName: z24.string(),
+  sessionId: z24.string().uuid()
+});
+var WsCallStartSchema = z24.object({
+  type: z24.literal("call:start"),
+  payload: StartCallSchema.extend({
+    projectId: z24.string().uuid()
+  })
+});
+var WsCallAcceptSchema = z24.object({
+  type: z24.literal("call:accept"),
+  payload: z24.object({ sessionId: z24.string().uuid() })
+});
+var WsCallDeclineSchema = z24.object({
+  type: z24.literal("call:decline"),
+  payload: z24.object({ sessionId: z24.string().uuid() })
+});
+var WsCallLeaveSchema = z24.object({
+  type: z24.literal("call:leave"),
+  payload: z24.object({ sessionId: z24.string().uuid() })
+});
+var WsCallEndSchema = z24.object({
+  type: z24.literal("call:end"),
+  payload: z24.object({ sessionId: z24.string().uuid() })
+});
+var WsStatusSetSchema = z24.object({
+  type: z24.literal("status:set"),
+  payload: z24.object({ status: z24.enum(["online", "away", "dnd"]) })
+});
+var WsServerCallRingSchema = z24.object({
+  type: z24.literal("call:ring"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    projectId: z24.string().uuid(),
+    conversationId: z24.string().uuid().nullable(),
+    callerId: z24.string().uuid(),
+    callerName: z24.string(),
+    participantIds: z24.array(z24.string().uuid())
+  })
+});
+var WsServerCallStartedSchema = z24.object({
+  type: z24.literal("call:started"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    projectId: z24.string().uuid(),
+    conversationId: z24.string().uuid().nullable()
+  })
+});
+var WsServerCallParticipantJoinedSchema = z24.object({
+  type: z24.literal("call:participant-joined"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    userId: z24.string().uuid(),
+    displayName: z24.string()
+  })
+});
+var WsServerCallParticipantLeftSchema = z24.object({
+  type: z24.literal("call:participant-left"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    userId: z24.string().uuid()
+  })
+});
+var WsServerCallEndedSchema = z24.object({
+  type: z24.literal("call:ended"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    projectId: z24.string().uuid()
+  })
+});
+var WsServerCallDeclinedSchema = z24.object({
+  type: z24.literal("call:declined"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    userId: z24.string().uuid()
+  })
+});
+var WsServerCallMissedSchema = z24.object({
+  type: z24.literal("call:missed"),
+  payload: z24.object({
+    sessionId: z24.string().uuid(),
+    projectId: z24.string().uuid(),
+    callerId: z24.string().uuid(),
+    callerName: z24.string()
+  })
+});
+var WsServerStatusUpdateSchema = z24.object({
+  type: z24.literal("status:update"),
+  payload: z24.object({
+    userId: z24.string().uuid(),
+    status: UserStatusSchema
+  })
+});
+
+// ../types/dist/chat.schema.js
+var ChatConversationTypeSchema = z25.enum(["group", "direct"]);
+var PushPlatformSchema = z25.enum(["web", "ios", "android"]);
+var ChatConversationSchema = z25.object({
+  id: z25.string().uuid(),
+  project_id: z25.string().uuid(),
+  type: ChatConversationTypeSchema,
+  name: z25.string().nullable(),
+  created_by: z25.string().uuid(),
+  created_at: z25.string().datetime({ offset: true }),
+  updated_at: z25.string().datetime({ offset: true })
+});
+var MessagePreviewSchema = z25.object({
+  id: z25.string().uuid(),
+  body: z25.string(),
+  sender_id: z25.string().uuid(),
+  created_at: z25.string().datetime({ offset: true })
+});
+var ChatConversationWithPreviewSchema = ChatConversationSchema.extend({
+  lastMessage: MessagePreviewSchema.nullable(),
+  unreadCount: z25.number().int().min(0),
+  participants: z25.array(UserProfileSchema),
+  projectName: z25.string(),
+  muted_at: z25.string().datetime({ offset: true }).nullable(),
+  pinned_at: z25.string().datetime({ offset: true }).nullable(),
+  enter_sends_override: z25.boolean().nullable().default(null)
+});
+var ChatParticipantSchema = z25.object({
+  id: z25.string().uuid(),
+  conversation_id: z25.string().uuid(),
+  user_id: z25.string().uuid(),
+  joined_at: z25.string().datetime({ offset: true }),
+  left_at: z25.string().datetime({ offset: true }).nullable(),
+  deleted_at: z25.string().datetime({ offset: true }).nullable(),
+  muted_at: z25.string().datetime({ offset: true }).nullable(),
+  pinned_at: z25.string().datetime({ offset: true }).nullable(),
+  enter_sends_override: z25.boolean().nullable().default(null)
+});
+var ChatParticipantWithProfileSchema = ChatParticipantSchema.extend({
+  user: UserProfileSchema
+});
+var ChatMessageSchema = z25.object({
+  id: z25.string().uuid(),
+  conversation_id: z25.string().uuid(),
+  sender_id: z25.string().uuid(),
+  body: z25.string().min(1).max(4e3),
+  attachment_url: z25.string().nullable(),
+  attachment_type: z25.string().nullable(),
+  mentions: z25.array(z25.string().uuid()),
+  reply_to_id: z25.string().uuid().nullable().default(null),
+  created_at: z25.string().datetime({ offset: true }),
+  updated_at: z25.string().datetime({ offset: true }),
+  deleted_at: z25.string().datetime({ offset: true }).nullable()
+});
+var ReplyPreviewSchema = z25.object({
+  id: z25.string().uuid(),
+  sender_id: z25.string().uuid(),
+  sender_name: z25.string(),
+  body: z25.string()
+});
+var ReactionAggregateSchema = z25.object({
+  emoji: z25.string().min(1),
+  count: z25.number().int().min(1),
+  userIds: z25.array(z25.string().uuid())
+});
+var ChatMessageWithReactionsSchema = ChatMessageSchema.extend({
+  sender: UserProfileSchema,
+  reactions: z25.array(ReactionAggregateSchema),
+  reply_to: ReplyPreviewSchema.nullable().default(null)
+});
+var ChatReactionSchema = z25.object({
+  id: z25.string().uuid(),
+  message_id: z25.string().uuid(),
+  user_id: z25.string().uuid(),
+  emoji: z25.string().min(1),
+  created_at: z25.string().datetime({ offset: true })
+});
+var ChatReadCursorSchema = z25.object({
+  id: z25.string().uuid(),
+  conversation_id: z25.string().uuid(),
+  user_id: z25.string().uuid(),
+  last_read_message_id: z25.string().uuid(),
+  last_read_at: z25.string().datetime({ offset: true })
+});
+var PushSubscriptionSchema = z25.object({
+  id: z25.string().uuid(),
+  user_id: z25.string().uuid(),
+  platform: PushPlatformSchema,
+  token: z25.string().min(1),
+  created_at: z25.string().datetime({ offset: true }),
+  updated_at: z25.string().datetime({ offset: true })
+});
+var NotificationPreferencesSchema = z25.object({
+  id: z25.string(),
+  user_id: z25.string().uuid(),
+  push_enabled: z25.boolean(),
+  push_dms: z25.boolean(),
+  push_group: z25.boolean(),
+  push_mentions: z25.boolean(),
+  quiet_hours_start: z25.string().nullable(),
+  quiet_hours_end: z25.string().nullable(),
+  updated_at: z25.string().datetime({ offset: true }),
+  chat_enter_sends: z25.boolean().default(true)
+});
+var CreateDMSchema = z25.object({
+  type: z25.literal("direct"),
+  participantId: z25.string().uuid()
+});
+var CreateGroupSchema = z25.object({
+  type: z25.literal("group"),
+  name: z25.string().min(1).max(50).refine((n) => n.toLowerCase() !== "general", { message: 'The name "general" is reserved' }),
+  participantIds: z25.array(z25.string().uuid()).min(2)
+});
+var CreateConversationSchema = z25.discriminatedUnion("type", [
+  CreateDMSchema,
+  CreateGroupSchema
+]);
+var SendMessageSchema = z25.object({
+  conversationId: z25.string().uuid(),
+  body: z25.string().max(4e3),
+  attachmentUrl: z25.string().optional(),
+  attachmentType: z25.string().optional(),
+  mentions: z25.array(z25.string().uuid()).optional(),
+  replyToId: z25.string().uuid().optional()
+}).refine((d) => d.body.length > 0 || !!d.attachmentUrl, { message: "Either body or attachmentUrl is required" });
+var UpdateMessageSchema = z25.object({
+  messageId: z25.string().uuid(),
+  body: z25.string().min(1).max(4e3)
+});
+var CreatePushSubscriptionSchema = z25.object({
+  platform: PushPlatformSchema,
+  token: z25.string().min(1)
+});
+var UpdateNotificationPreferencesSchema = z25.object({
+  push_enabled: z25.boolean().optional(),
+  push_dms: z25.boolean().optional(),
+  push_group: z25.boolean().optional(),
+  push_mentions: z25.boolean().optional(),
+  quiet_hours_start: z25.string().nullable().optional(),
+  quiet_hours_end: z25.string().nullable().optional(),
+  chat_enter_sends: z25.boolean().optional()
+});
+var WsMessageSendSchema = z25.object({
+  type: z25.literal("message:send"),
+  payload: SendMessageSchema
+});
+var WsMessageEditSchema = z25.object({
+  type: z25.literal("message:edit"),
+  payload: UpdateMessageSchema
+});
+var WsMessageDeleteSchema = z25.object({
+  type: z25.literal("message:delete"),
+  payload: z25.object({ messageId: z25.string().uuid() })
+});
+var WsTypingStartSchema = z25.object({
+  type: z25.literal("typing:start"),
+  payload: z25.object({ conversationId: z25.string().uuid() })
+});
+var WsTypingStopSchema = z25.object({
+  type: z25.literal("typing:stop"),
+  payload: z25.object({ conversationId: z25.string().uuid() })
+});
+var WsReactionAddSchema = z25.object({
+  type: z25.literal("reaction:add"),
+  payload: z25.object({ messageId: z25.string().uuid(), emoji: z25.string().min(1) })
+});
+var WsReactionRemoveSchema = z25.object({
+  type: z25.literal("reaction:remove"),
+  payload: z25.object({ messageId: z25.string().uuid(), emoji: z25.string().min(1) })
+});
+var WsCursorUpdateSchema = z25.object({
+  type: z25.literal("cursor:update"),
+  payload: z25.object({
+    conversationId: z25.string().uuid(),
+    lastReadMessageId: z25.string().uuid()
+  })
+});
+var WsPingSchema = z25.object({
+  type: z25.literal("ping"),
+  payload: z25.object({})
+});
+var WsChatClientEvents = [
+  WsMessageSendSchema,
+  WsMessageEditSchema,
+  WsMessageDeleteSchema,
+  WsTypingStartSchema,
+  WsTypingStopSchema,
+  WsReactionAddSchema,
+  WsReactionRemoveSchema,
+  WsCursorUpdateSchema,
+  WsPingSchema,
+  WsCallStartSchema,
+  WsCallAcceptSchema,
+  WsCallDeclineSchema,
+  WsCallLeaveSchema,
+  WsCallEndSchema,
+  WsStatusSetSchema
+];
+var WsClientEventSchema = z25.discriminatedUnion("type", [
+  ...WsChatClientEvents,
+  ...WsBoardClientEvents
+]);
+var WsServerMessageNewSchema = z25.object({
+  type: z25.literal("message:new"),
+  payload: z25.object({ projectId: z25.string().uuid(), message: ChatMessageWithReactionsSchema })
+});
+var WsServerMessageUpdatedSchema = z25.object({
+  type: z25.literal("message:updated"),
+  payload: z25.object({ projectId: z25.string().uuid(), message: ChatMessageWithReactionsSchema })
+});
+var WsServerMessageDeletedSchema = z25.object({
+  type: z25.literal("message:deleted"),
+  payload: z25.object({ projectId: z25.string().uuid(), messageId: z25.string().uuid(), conversationId: z25.string().uuid() })
+});
+var WsServerTypingUpdateSchema = z25.object({
+  type: z25.literal("typing:update"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    conversationId: z25.string().uuid(),
+    userId: z25.string().uuid(),
+    isTyping: z25.boolean()
+  })
+});
+var WsServerPresenceJoinSchema = z25.object({
+  type: z25.literal("presence:join"),
+  payload: z25.object({ userId: z25.string().uuid(), projectId: z25.string().uuid() })
+});
+var WsServerPresenceLeaveSchema = z25.object({
+  type: z25.literal("presence:leave"),
+  payload: z25.object({ userId: z25.string().uuid(), projectId: z25.string().uuid() })
+});
+var WsServerPresenceStateSchema = z25.object({
+  type: z25.literal("presence:state"),
+  payload: z25.object({
+    online: z25.array(z25.string().uuid()),
+    statuses: z25.record(z25.string(), UserStatusSchema).optional()
+  })
+});
+var WsServerReactionAddedSchema = z25.object({
+  type: z25.literal("reaction:added"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    messageId: z25.string().uuid(),
+    reaction: z25.object({
+      userId: z25.string().uuid(),
+      emoji: z25.string().min(1)
+    })
+  })
+});
+var WsServerReactionRemovedSchema = z25.object({
+  type: z25.literal("reaction:removed"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    messageId: z25.string().uuid(),
+    userId: z25.string().uuid(),
+    emoji: z25.string().min(1)
+  })
+});
+var WsServerCursorUpdatedSchema = z25.object({
+  type: z25.literal("cursor:updated"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    conversationId: z25.string().uuid(),
+    userId: z25.string().uuid(),
+    lastReadMessageId: z25.string().uuid()
+  })
+});
+var WsServerPongSchema = z25.object({
+  type: z25.literal("pong"),
+  payload: z25.object({})
+});
+var WsServerErrorSchema = z25.object({
+  type: z25.literal("error"),
+  payload: z25.object({ code: z25.string(), message: z25.string() })
+});
+var WsServerSubscriptionUpdateSchema = z25.object({
+  type: z25.literal("subscription:update"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    action: z25.enum(["added", "removed"]),
+    project: z25.object({
+      id: z25.string().uuid(),
+      name: z25.string(),
+      role: z25.string()
+    }).optional()
+  })
+});
+var WsServerConversationCreatedSchema = z25.object({
+  type: z25.literal("conversation:created"),
+  payload: z25.object({
+    conversation: ChatConversationWithPreviewSchema
+  })
+});
+var WsServerConversationUpdatedSchema = z25.object({
+  type: z25.literal("conversation:updated"),
+  payload: z25.object({
+    conversationId: z25.string().uuid(),
+    changes: z25.object({
+      name: z25.string().optional(),
+      participantsAdded: z25.array(z25.string().uuid()).optional(),
+      participantsRemoved: z25.array(z25.string().uuid()).optional()
+    })
+  })
+});
+var WsServerConversationDeletedSchema = z25.object({
+  type: z25.literal("conversation:deleted"),
+  payload: z25.object({
+    conversationId: z25.string().uuid(),
+    projectId: z25.string().uuid()
+  })
+});
+var WsServerUnreadSyncSchema = z25.object({
+  type: z25.literal("unread:sync"),
+  payload: z25.object({
+    projects: z25.array(z25.object({ projectId: z25.string().uuid(), count: z25.number().int().min(0) })),
+    conversations: z25.array(z25.object({ conversationId: z25.string().uuid(), count: z25.number().int().min(0) }))
+  })
+});
+var WsServerDocumentCreatedSchema = z25.object({
+  type: z25.literal("document:created"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    spaceId: z25.string().uuid(),
+    document: z25.object({ id: z25.string().uuid(), title: z25.string() })
+  })
+});
+var WsServerDocumentUpdatedSchema = z25.object({
+  type: z25.literal("document:updated"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    spaceId: z25.string().uuid(),
+    document: z25.object({ id: z25.string().uuid(), title: z25.string() })
+  })
+});
+var WsServerDocumentDeletedSchema = z25.object({
+  type: z25.literal("document:deleted"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    spaceId: z25.string().uuid(),
+    documentId: z25.string().uuid()
+  })
+});
+var WsServerSpaceCreatedSchema = z25.object({
+  type: z25.literal("space:created"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    space: z25.object({ id: z25.string().uuid(), name: z25.string() })
+  })
+});
+var WsServerSpaceUpdatedSchema = z25.object({
+  type: z25.literal("space:updated"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    space: z25.object({ id: z25.string().uuid(), name: z25.string() })
+  })
+});
+var WsServerSpaceDeletedSchema = z25.object({
+  type: z25.literal("space:deleted"),
+  payload: z25.object({
+    projectId: z25.string().uuid(),
+    spaceId: z25.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 = z25.discriminatedUnion("type", [
+  ...WsChatServerEvents,
+  ...WsBoardServerEvents
+]);
+
+// ../types/dist/api-token.schema.js
+import { z as z26 } from "zod";
+var ApiTokenMetadataSchema = z26.object({
+  id: z26.string().uuid(),
+  name: z26.string().min(1),
+  token_prefix: z26.string(),
+  last_used_at: z26.string().datetime({ offset: true }).nullable(),
+  created_at: z26.string().datetime({ offset: true })
+});
+var GenerateApiTokenResponseSchema = z26.object({
+  id: z26.string().uuid(),
+  name: z26.string().min(1),
+  token_prefix: z26.string(),
+  token: z26.string(),
+  created_at: z26.string().datetime({ offset: true })
+});
+var CreateApiTokenBodySchema = z26.object({
+  name: z26.string().min(1).max(100).optional().default("Claude Code")
+});
+
+// ../types/dist/doc-space.schema.js
+import { z as z27 } from "zod";
+var DocSpaceSchema = z27.object({
+  id: z27.string().uuid(),
+  project_id: z27.string().uuid(),
+  name: z27.string().min(1).max(100),
+  prefix: z27.string().regex(/^[A-Z]{2,10}$/),
+  doc_counter: z27.number().int().nonnegative(),
+  created_at: z27.string().datetime({ offset: true }),
+  updated_at: z27.string().datetime({ offset: true })
+});
+var DocSpaceWithCountSchema = DocSpaceSchema.extend({
+  document_count: z27.number().int().nonnegative(),
+  can_write: z27.boolean()
+});
+var CreateDocSpaceSchema = z27.object({
+  name: z27.string().trim().min(1).max(100),
+  prefix: z27.string().regex(/^[A-Z]{2,10}$/)
+});
+var UpdateDocSpaceSchema = z27.object({
+  name: z27.string().trim().min(1).max(100).optional(),
+  prefix: z27.string().regex(/^[A-Z]{2,10}$/).optional()
+});
+var DocumentActionSchema = z27.enum(["delete", "move"]);
+var DeleteDocSpaceBodySchema = z27.object({
+  document_action: DocumentActionSchema.default("delete"),
+  target_space_id: z27.string().uuid().optional()
+}).superRefine((data, ctx) => {
+  if (data.document_action === "move" && !data.target_space_id) {
+    ctx.addIssue({
+      code: z27.ZodIssueCode.custom,
+      message: "target_space_id is required when document_action is move",
+      path: ["target_space_id"]
+    });
+  }
+});
+var DeleteDocSpacePreviewSchema = z27.object({
+  documents: z27.number().int().nonnegative()
+});
+
+// ../types/dist/document.schema.js
+import { z as z28 } from "zod";
+var DocumentSchema = z28.object({
+  id: z28.string().uuid(),
+  space_id: z28.string().uuid(),
+  project_id: z28.string().uuid(),
+  parent_id: z28.string().uuid().nullable(),
+  doc_number: z28.number().int().positive(),
+  title: z28.string().min(1).max(500),
+  content: z28.string(),
+  position: z28.number().int(),
+  created_by: z28.string().uuid(),
+  updated_by: z28.string().uuid(),
+  created_at: z28.string().datetime({ offset: true }),
+  updated_at: z28.string().datetime({ offset: true })
+});
+var DocumentWithProfilesSchema = DocumentSchema.extend({
+  creator: UserProfileSchema,
+  updater: UserProfileSchema
+});
+var DocumentTreeNodeSchema = DocumentSchema.extend({
+  children: z28.lazy(() => DocumentTreeNodeSchema.array())
+});
+var CreateDocumentSchema = z28.object({
+  title: z28.string().trim().min(1).max(500),
+  content: z28.string().optional().default(""),
+  parent_id: z28.string().uuid().nullable().optional().default(null)
+});
+var UpdateDocumentSchema = z28.object({
+  title: z28.string().trim().min(1).max(500).optional(),
+  content: z28.string().optional()
+});
+var MoveDocumentSchema = z28.object({
+  parent_id: z28.string().uuid().nullable().optional(),
+  position: z28.number().int().nonnegative().optional()
+});
+var DeleteDocumentPreviewSchema = z28.object({
+  child_documents: z28.number().int().nonnegative()
+});
+
+// ../types/dist/search.schema.js
+import { z as z29 } from "zod";
+var SearchResultTypeSchema = z29.enum(["ticket", "document", "message"]);
+var SearchResultSchema = z29.object({
+  type: SearchResultTypeSchema,
+  id: z29.string().uuid(),
+  display_id: z29.string().nullable(),
+  project_id: z29.string().uuid(),
+  project_name: z29.string(),
+  title: z29.string(),
+  snippet: z29.string(),
+  meta: z29.record(z29.string(), z29.unknown()).optional()
+});
+var SearchQuerySchema = z29.object({
+  q: z29.string().min(2),
+  type: SearchResultTypeSchema.optional(),
+  project_id: z29.string().uuid().optional(),
+  limit: z29.coerce.number().int().min(1).max(50).optional().default(20)
+});
+var SearchResponseSchema = z29.object({
+  results: z29.array(SearchResultSchema),
+  total: z29.number().int().nonnegative()
+});
+var MentionResultTypeSchema = z29.enum(["ticket", "document", "user"]);
+var MentionResultSchema = z29.object({
+  type: MentionResultTypeSchema,
+  id: z29.string().uuid(),
+  displayId: z29.string(),
+  title: z29.string(),
+  avatarUrl: z29.string().optional()
+});
+
+// ../types/dist/entity-reference.schema.js
+import { z as z30 } from "zod";
+var EntityReferenceSourceTypeSchema = z30.enum(["ticket", "document", "comment", "chat_message"]);
+var EntityReferenceTargetTypeSchema = z30.enum(["ticket", "document"]);
+var EntityReferenceSchema = z30.object({
+  id: z30.string().uuid(),
+  source_type: EntityReferenceSourceTypeSchema,
+  source_id: z30.string().uuid(),
+  target_type: EntityReferenceTargetTypeSchema,
+  target_id: z30.string().uuid(),
+  project_id: z30.string().uuid(),
+  created_at: z30.string().datetime({ offset: true })
+});
+var BacklinkSchema = z30.object({
+  source_type: EntityReferenceSourceTypeSchema,
+  source_id: z30.string().uuid(),
+  display_id: z30.string(),
+  title: z30.string()
+});
+var BacklinksResponseSchema = z30.object({
+  backlinks: z30.array(BacklinkSchema),
+  total: z30.number().int().nonnegative()
+});
+var ResolveResultSchema = z30.object({
+  type: EntityReferenceTargetTypeSchema,
+  id: z30.string().uuid(),
+  boardId: z30.string().uuid().optional(),
+  spaceId: z30.string().uuid().optional()
+});
+var BatchResolveResponseSchema = z30.object({
+  results: z30.record(z30.string(), ResolveResultSchema)
+});
+
+// ../types/dist/notification.schema.js
+import { z as z31 } from "zod";
+var NotificationTypeSchema = z31.enum(["mention"]);
+var NotificationSchema = z31.object({
+  id: z31.string().uuid(),
+  project_id: z31.string().uuid(),
+  user_id: z31.string().uuid(),
+  actor_id: z31.string().uuid(),
+  type: NotificationTypeSchema,
+  source_type: z31.string(),
+  source_id: z31.string().uuid(),
+  display_id: z31.string(),
+  title: z31.string(),
+  read: z31.boolean(),
+  created_at: z31.string().datetime({ offset: true })
+});
+var NotificationWithActorSchema = NotificationSchema.extend({
+  actor: z31.object({
+    id: z31.string().uuid(),
+    display_name: z31.string(),
+    avatar_url: z31.string().nullable()
+  }).nullable()
+});
+var NotificationsResponseSchema = z31.object({
+  notifications: z31.array(NotificationWithActorSchema),
+  unread_count: z31.number().int().nonnegative()
+});
+
+// ../types/dist/field-value.schema.js
+import { z as z32 } from "zod";
+var FieldValueSchema = z32.object({
+  id: z32.string().uuid(),
+  ticket_id: z32.string().uuid(),
+  field_id: z32.string().uuid(),
+  text_value: z32.string().nullable(),
+  number_value: z32.number().nullable(),
+  date_value: z32.string().nullable(),
+  json_value: z32.unknown().nullable(),
+  ref_user_id: z32.string().uuid().nullable(),
+  ref_ticket_id: z32.string().uuid().nullable(),
+  ref_document_id: z32.string().uuid().nullable(),
+  created_at: z32.string().datetime({ offset: true }),
+  updated_at: z32.string().datetime({ offset: true })
+});
+var FieldValueWithDefinitionSchema = FieldValueSchema.extend({
+  field_name: z32.string(),
+  field_type: z32.string()
+});
+var SetFieldValueSchema = z32.object({
+  value: z32.unknown()
+});
+var BatchSetFieldValuesSchema = z32.object({
+  values: z32.record(z32.string(), z32.unknown())
+});
+
+// ../types/dist/transition-requirement.schema.js
+import { z as z33 } from "zod";
+var TransitionFieldRequirementSchema = z33.object({
+  id: z33.string().uuid(),
+  board_id: z33.string().uuid(),
+  to_column_id: z33.string().uuid().nullable(),
+  field_id: z33.string().uuid(),
+  to_tombstone_id: z33.string().uuid().nullable(),
+  status: TransitionRuleStatusSchema,
+  instruction: z33.string().nullable(),
+  created_at: z33.string().datetime({ offset: true }),
+  updated_at: z33.string().datetime({ offset: true })
+});
+var TransitionFieldRequirementWithTombstoneSchema = TransitionFieldRequirementSchema.extend({
+  to_tombstone_name: z33.string().nullable().default(null),
+  field_name: z33.string().default(""),
+  field_type: z33.string().default("")
+});
+var BulkUpsertTransitionRequirementsSchema = z33.object({
+  requirements: z33.array(z33.object({
+    to_column_id: z33.string().uuid(),
+    field_id: z33.string().uuid(),
+    instruction: z33.string().nullable().optional()
+  }))
+});
+
+// ../types/dist/transition-blocked.schema.js
+import { z as z34 } from "zod";
+var ColumnInfoSchema = z34.object({
+  id: z34.string().uuid(),
+  name: z34.string()
+});
+var WorkflowViolationSchema = z34.object({
+  type: z34.literal("workflow"),
+  message: z34.string(),
+  from_column: ColumnInfoSchema,
+  to_column: ColumnInfoSchema,
+  allowed_targets: z34.array(ColumnInfoSchema)
+});
+var MissingFieldsViolationSchema = z34.object({
+  type: z34.literal("missing_fields"),
+  message: z34.string(),
+  fields: z34.array(z34.object({
+    field_id: z34.string().uuid(),
+    name: z34.string(),
+    type: z34.string(),
+    config: z34.record(z34.string(), z34.unknown()).default({})
+  }))
+});
+var UnresolvedDependenciesViolationSchema = z34.object({
+  type: z34.literal("unresolved_dependencies"),
+  message: z34.string(),
+  blocking_tickets: z34.array(z34.object({
+    id: z34.string().uuid(),
+    ticket_number: z34.number().int(),
+    title: z34.string(),
+    column: z34.string()
+  }))
+});
+var TransitionViolationSchema = z34.discriminatedUnion("type", [
+  WorkflowViolationSchema,
+  MissingFieldsViolationSchema,
+  UnresolvedDependenciesViolationSchema
+]);
+var TransitionBlockedErrorSchema = z34.object({
+  success: z34.literal(false),
+  error: z34.object({
+    code: z34.literal("TRANSITION_BLOCKED"),
+    violations: z34.array(TransitionViolationSchema)
+  })
+});
+
+// ../types/dist/ticket-link.schema.js
+import { z as z35 } from "zod";
+var TicketLinkTypeSchema = z35.enum(["blocks", "relates_to", "duplicates"]);
+var ResolvedWhenSchema = z35.discriminatedUnion("type", [
+  z35.object({
+    type: z35.literal("column"),
+    column_ids: z35.array(z35.string().uuid()).min(1)
+  }),
+  z35.object({
+    type: z35.literal("archived")
+  }),
+  z35.object({
+    type: z35.literal("column_or_archived"),
+    column_ids: z35.array(z35.string().uuid())
+  })
+]);
+var TicketLinkSchema = z35.object({
+  id: z35.string().uuid(),
+  source_id: z35.string().uuid(),
+  target_id: z35.string().uuid(),
+  link_type: TicketLinkTypeSchema,
+  project_id: z35.string().uuid(),
+  created_by: z35.string().uuid(),
+  created_at: z35.string().datetime({ offset: true }),
+  updated_at: z35.string().datetime({ offset: true }),
+  resolved_at: z35.string().datetime({ offset: true }).nullable().optional(),
+  resolved_by: z35.string().uuid().nullable().optional()
+});
+var TicketLinkWithDetailsSchema = TicketLinkSchema.extend({
+  source: z35.object({
+    id: z35.string().uuid(),
+    ticket_number: z35.number().int(),
+    title: z35.string(),
+    column_name: z35.string().nullable()
+  }),
+  target: z35.object({
+    id: z35.string().uuid(),
+    ticket_number: z35.number().int(),
+    title: z35.string(),
+    column_name: z35.string().nullable()
+  })
+});
+var CreateTicketLinkSchema = z35.object({
+  source_ticket_id: z35.string().uuid(),
+  target_ticket_id: z35.string().uuid(),
+  link_type: TicketLinkTypeSchema
+});
+var DependencyRequirementSchema = z35.object({
+  id: z35.string().uuid(),
+  board_id: z35.string().uuid(),
+  to_column_id: z35.string().uuid().nullable().optional(),
+  to_tombstone_id: z35.string().uuid().nullable().optional(),
+  instruction: z35.string().nullable().optional(),
+  status: z35.enum(["active", "broken"]),
+  resolved_when: ResolvedWhenSchema.nullable().optional(),
+  created_at: z35.string().datetime({ offset: true }),
+  updated_at: z35.string().datetime({ offset: true })
+});
+
+// ../types/dist/column-tombstone.schema.js
+import { z as z36 } from "zod";
+var ColumnTombstoneSchema = z36.object({
+  id: z36.string().uuid(),
+  board_id: z36.string().uuid(),
+  name: z36.string(),
+  color: z36.string(),
+  deleted_at: z36.string().datetime({ offset: true })
+});
+
+// ../types/dist/gif.schema.js
+import { z as z37 } from "zod";
+var GifSchema = z37.object({
+  id: z37.string(),
+  title: z37.string(),
+  url: z37.string().url(),
+  preview_url: z37.string().url(),
+  width: z37.number().int(),
+  height: z37.number().int()
+});
+var GifSearchQuerySchema = z37.object({
+  q: z37.string().min(1).max(100)
+});
+var GifResponseSchema = z37.object({
+  gifs: z37.array(GifSchema)
+});
+
+// ../types/dist/preferences.schema.js
+import { z as z38 } from "zod";
+var ThemePaletteSchema = z38.enum(["kantban", "seventies-coffee"]);
+var ThemeModeSchema = z38.enum(["light", "dark", "system"]);
+var UserPreferencesSchema = z38.object({
+  user_id: z38.string().uuid(),
+  theme_palette: ThemePaletteSchema,
+  theme_mode: ThemeModeSchema
+});
+var UpdateUserPreferencesSchema = z38.object({
+  theme_palette: ThemePaletteSchema.optional(),
+  theme_mode: ThemeModeSchema.optional()
+});
+
+// ../types/dist/activity.schema.js
+import { z as z39 } from "zod";
+var ActivityActionSchema = z39.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 = z39.enum([
+  "ticket",
+  "comment",
+  "field_value",
+  "board",
+  "document",
+  "ticket_reference",
+  "pipeline_template",
+  "signal",
+  "column",
+  "pipeline_session"
+]);
+var ActivityLogSchema = z39.object({
+  id: z39.string().uuid(),
+  project_id: z39.string().uuid(),
+  actor_id: z39.string().uuid(),
+  action: ActivityActionSchema,
+  resource_type: ActivityResourceTypeSchema,
+  resource_id: z39.string().uuid(),
+  board_id: z39.string().uuid().nullable().default(null),
+  ticket_id: z39.string().uuid().nullable().default(null),
+  metadata: z39.record(z39.string(), z39.unknown()).default({}),
+  created_at: z39.string().datetime({ offset: true })
+});
+var ActivityFeedQuerySchema = z39.object({
+  since: z39.string().datetime({ offset: true }).optional(),
+  types: z39.string().optional(),
+  via: z39.string().optional(),
+  boardId: z39.string().uuid().optional(),
+  ticketId: z39.string().uuid().optional(),
+  columnId: z39.string().uuid().optional(),
+  sessionId: z39.string().uuid().optional(),
+  limit: z39.coerce.number().int().min(1).max(200).optional().default(20),
+  cursor: z39.string().optional()
+});
+
+// ../types/dist/ticket-metrics.schema.js
+import { z as z40 } from "zod";
+var TicketMetricsSchema = z40.object({
+  ticket_id: z40.string().uuid(),
+  board_id: z40.string().uuid(),
+  project_id: z40.string().uuid(),
+  created_at: z40.string().datetime({ offset: true }),
+  first_active_at: z40.string().datetime({ offset: true }).nullable(),
+  done_at: z40.string().datetime({ offset: true }),
+  lead_time_hours: z40.number(),
+  cycle_time_hours: z40.number().nullable(),
+  column_transitions: z40.number().int(),
+  backward_moves: z40.number().int(),
+  assignee_changes: z40.number().int(),
+  labels: z40.record(z40.string(), z40.unknown()).default({})
+});
+
+// ../types/dist/daily-snapshot.schema.js
+import { z as z41 } from "zod";
+var DailySnapshotSchema = z41.object({
+  id: z41.string().uuid(),
+  project_id: z41.string().uuid(),
+  board_id: z41.string().uuid(),
+  snapshot_date: z41.string(),
+  column_id: z41.string().uuid(),
+  column_name: z41.string(),
+  ticket_count: z41.number().int()
+});
+
+// ../types/dist/compound.schema.js
+import { z as z42 } from "zod";
+var PlanItemSchema = z42.object({
+  title: z42.string().min(1).max(500),
+  description: z42.string().max(1e4).optional(),
+  columnName: z42.string().optional(),
+  fieldValues: z42.record(z42.string(), z42.unknown()).optional(),
+  subtasks: z42.array(z42.object({
+    title: z42.string().min(1).max(500),
+    description: z42.string().max(1e4).optional()
+  })).optional()
+});
+var PlanToTicketsBodySchema = z42.object({
+  plan: z42.array(PlanItemSchema).min(1).max(50),
+  dryRun: z42.boolean().optional().default(true)
+});
+var SuggestNextTaskQuerySchema = z42.object({
+  boardId: z42.string().uuid().optional(),
+  userId: z42.string().uuid().optional(),
+  count: z42.coerce.number().optional().default(5)
+});
+var TaskScoreSchema = z42.object({
+  ticketId: z42.string().uuid(),
+  ticketNumber: z42.number(),
+  title: z42.string(),
+  score: z42.number(),
+  breakdown: z42.record(z42.string(), z42.number()),
+  reasoning: z42.string(),
+  columnName: z42.string(),
+  boardName: z42.string(),
+  assigneeName: z42.string().nullable(),
+  timeInColumn: z42.number(),
+  timeUnit: z42.enum(["minutes", "hours", "days"]).default("days")
+});
+var StartWorkingBodySchema = z42.object({
+  moveToColumn: z42.string().optional()
+});
+var CompleteTaskBodySchema = z42.object({
+  moveToColumn: z42.string().optional(),
+  completionComment: z42.string().max(1e4).optional(),
+  suggestNext: z42.boolean().optional().default(true),
+  handoff: z42.record(z42.string(), z42.unknown()).optional()
+});
+var BottleneckResultSchema = z42.object({
+  wip_violations: z42.array(z42.object({
+    column: z42.string(),
+    limit: z42.number(),
+    actual: z42.number(),
+    tickets: z42.array(z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() }))
+  })),
+  stuck_tickets: z42.array(z42.object({
+    ticket: z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() }),
+    column: z42.string(),
+    time_in_column: z42.number(),
+    time_unit: z42.enum(["minutes", "hours", "days"]).default("days"),
+    last_activity_at: z42.string().nullable()
+  })),
+  blocked_chains: z42.array(z42.object({
+    blocking_ticket: z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() }),
+    blocked_tickets: z42.array(z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() })),
+    reason: z42.string()
+  })),
+  unassigned_active: z42.array(z42.object({
+    ticket: z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() }),
+    column: z42.string()
+  })),
+  suggestions: z42.array(z42.string()),
+  circuit_breaker_proximity: z42.array(z42.object({
+    ticket: z42.object({ id: z42.string(), title: z42.string(), ticket_number: z42.number() }),
+    column: z42.string(),
+    backward_transitions: z42.number(),
+    threshold: z42.number()
+  })).optional()
+});
+var TicketContextSchema = z42.object({
+  ticket: z42.record(z42.string(), z42.unknown()),
+  comments: z42.array(z42.record(z42.string(), z42.unknown())),
+  field_values: z42.array(z42.record(z42.string(), z42.unknown())),
+  linked_tickets: z42.array(z42.record(z42.string(), z42.unknown())),
+  linked_documents: z42.array(z42.record(z42.string(), z42.unknown())),
+  references: z42.array(z42.record(z42.string(), z42.unknown())),
+  signals: z42.array(z42.record(z42.string(), z42.unknown())).optional(),
+  transitions: z42.array(z42.record(z42.string(), z42.unknown())).optional()
+});
+var ChunkedSearchBodySchema = z42.object({
+  query: z42.string().min(1),
+  maxChunks: z42.number().optional().default(5)
+});
+
+// ../types/dist/dashboard.schema.js
+import { z as z43 } from "zod";
+var DashboardBoardSummarySchema = z43.object({
+  id: z43.string().uuid(),
+  name: z43.string(),
+  columns: z43.array(z43.object({
+    id: z43.string().uuid(),
+    name: z43.string(),
+    ticket_count: z43.number(),
+    wip_limit: z43.number().nullable()
+  })),
+  total_tickets: z43.number()
+});
+var DashboardProjectSchema = z43.object({
+  id: z43.string().uuid(),
+  name: z43.string(),
+  ticket_prefix: z43.string(),
+  boards: z43.array(DashboardBoardSummarySchema),
+  my_tickets: z43.array(z43.object({
+    id: z43.string().uuid(),
+    ticket_number: z43.number(),
+    title: z43.string(),
+    board_name: z43.string(),
+    column_name: z43.string().nullable(),
+    time_in_column: z43.number().nullable(),
+    time_unit: z43.enum(["minutes", "hours", "days"]).default("days")
+  }))
+});
+var UserDashboardSchema = z43.object({
+  projects: z43.array(DashboardProjectSchema),
+  urgent: z43.array(z43.object({
+    type: z43.string(),
+    message: z43.string(),
+    ticket_id: z43.string().uuid().optional(),
+    board_id: z43.string().uuid().optional()
+  }))
+});
+
+// ../types/dist/github.schema.js
+import { z as z44 } from "zod";
+var GithubConnectionSchema = z44.object({
+  id: z44.string().uuid(),
+  user_id: z44.string().uuid(),
+  github_user_id: z44.string(),
+  github_username: z44.string(),
+  scopes: z44.array(z44.string()),
+  created_at: z44.string().datetime({ offset: true })
+});
+var ProjectGithubRepoSchema = z44.object({
+  id: z44.string().uuid(),
+  project_id: z44.string().uuid(),
+  github_repo_owner: z44.string(),
+  github_repo_name: z44.string(),
+  github_repo_id: z44.number().int(),
+  connected_by: z44.string().uuid(),
+  webhook_id: z44.number().int().nullable(),
+  created_at: z44.string().datetime({ offset: true }),
+  updated_at: z44.string().datetime({ offset: true })
+});
+var ConnectGithubRepoBodySchema = z44.object({
+  repo_owner: z44.string().min(1),
+  repo_name: z44.string().min(1)
+});
+
+// ../types/dist/ticket-reference.schema.js
+import { z as z45 } from "zod";
+var TicketReferenceProviderSchema = z45.enum(["github"]);
+var TicketReferenceTypeSchema = z45.enum(["pull_request", "branch", "commit"]);
+var TicketReferenceStatusSchema = z45.enum(["open", "closed", "merged", "draft", "active", "deleted", "none"]);
+var TicketReferenceLinkedBySchema = z45.enum(["convention", "manual"]);
+var TicketReferenceSchema = z45.object({
+  id: z45.string().uuid(),
+  ticket_id: z45.string().uuid(),
+  project_id: z45.string().uuid(),
+  provider: TicketReferenceProviderSchema,
+  type: TicketReferenceTypeSchema,
+  external_id: z45.string(),
+  external_url: z45.string().url(),
+  title: z45.string(),
+  status: TicketReferenceStatusSchema,
+  metadata: z45.record(z45.string(), z45.unknown()).default({}),
+  linked_by: TicketReferenceLinkedBySchema,
+  synced_at: z45.string().datetime({ offset: true }).nullable(),
+  created_at: z45.string().datetime({ offset: true })
+});
+var LinkGithubReferenceBodySchema = z45.object({
+  type: TicketReferenceTypeSchema,
+  url: z45.string().url()
+});
+
+// ../types/dist/analytics.schema.js
+import { z as z46 } from "zod";
+var AnalyticsQuerySchema = z46.object({
+  boardId: z46.string().uuid().optional(),
+  since: z46.string().datetime({ offset: true }).optional(),
+  until: z46.string().datetime({ offset: true }).optional(),
+  assigneeId: z46.string().uuid().optional(),
+  resolution: z46.enum(["auto", "minutes", "hours", "days"]).optional().default("auto")
+});
+var VelocityQuerySchema = AnalyticsQuerySchema.extend({
+  weeks: z46.coerce.number().int().min(1).max(52).optional().default(8)
+});
+var ForecastQuerySchema = z46.object({
+  boardId: z46.string().uuid().optional(),
+  remainingTickets: z46.coerce.number().int().min(0).optional(),
+  targetDate: z46.string().date().optional()
+});
+var EstimationQuerySchema = z46.object({
+  ticketId: z46.string().uuid()
+});
+var RetrospectiveQuerySchema = AnalyticsQuerySchema.extend({
+  periodDays: z46.coerce.number().int().min(1).max(365).optional().default(14)
+});
+var VelocityWeekSchema = z46.object({
+  week_start: z46.string(),
+  completed: z46.number().int(),
+  avg_cycle_time_value: z46.number().nullable()
+});
+var VelocityResponseSchema = z46.object({
+  weeks: z46.array(VelocityWeekSchema),
+  trend: z46.enum(["up", "down", "stable"]),
+  avg_throughput: z46.number(),
+  time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+});
+var CycleTimeDataPointSchema = z46.object({
+  ticket_id: z46.string().uuid(),
+  ticket_number: z46.number().int().optional(),
+  title: z46.string().optional(),
+  done_at: z46.string(),
+  cycle_time_value: z46.number()
+});
+var CycleTimeResponseSchema = z46.object({
+  data_points: z46.array(CycleTimeDataPointSchema),
+  percentiles: z46.object({
+    p50: z46.number(),
+    p85: z46.number(),
+    p95: z46.number()
+  }),
+  avg_cycle_time_value: z46.number(),
+  total_tickets: z46.number().int(),
+  time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+});
+var LeadTimeBucketSchema = z46.object({
+  range_label: z46.string(),
+  min_hours: z46.number(),
+  max_hours: z46.number(),
+  count: z46.number().int()
+});
+var LeadTimeResponseSchema = z46.object({
+  buckets: z46.array(LeadTimeBucketSchema),
+  percentiles: z46.object({
+    p50: z46.number(),
+    p85: z46.number(),
+    p95: z46.number()
+  }),
+  avg_lead_time_value: z46.number(),
+  total_tickets: z46.number().int(),
+  time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+});
+var CfdColumnDataSchema = z46.object({
+  column_name: z46.string(),
+  count: z46.number().int()
+});
+var CfdDateEntrySchema = z46.object({
+  date: z46.string(),
+  columns: z46.array(CfdColumnDataSchema)
+});
+var CfdResponseSchema = z46.object({
+  entries: z46.array(CfdDateEntrySchema),
+  column_names: z46.array(z46.string())
+});
+var ForecastProbabilitySchema = z46.object({
+  confidence: z46.number(),
+  date: z46.string(),
+  weeks: z46.number()
+});
+var ForecastResponseSchema = z46.object({
+  remaining_tickets: z46.number().int(),
+  simulations: z46.number().int(),
+  probabilities: z46.array(ForecastProbabilitySchema),
+  target_date_probability: z46.number().nullable(),
+  weekly_throughput_avg: z46.number(),
+  weekly_throughput_stddev: z46.number(),
+  data_weeks: z46.number().int()
+});
+var EstimationResponseSchema = z46.object({
+  ticket_id: z46.string().uuid(),
+  similar_count: z46.number().int(),
+  cycle_time_estimate: z46.object({
+    min: z46.number(),
+    max: z46.number(),
+    avg: z46.number(),
+    median: z46.number(),
+    p85: z46.number()
+  }).nullable(),
+  similar_tickets: z46.array(z46.object({
+    ticket_id: z46.string().uuid(),
+    title: z46.string(),
+    cycle_time_value: z46.number(),
+    keyword_overlap: z46.number().int()
+  })),
+  time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+});
+var RetrospectiveInsightsSchema = z46.object({
+  period_days: z46.number().int(),
+  throughput: z46.object({
+    created: z46.number().int(),
+    completed: z46.number().int(),
+    net: z46.number().int()
+  }),
+  bottlenecks: z46.object({
+    high_backward_moves: z46.array(z46.object({
+      ticket_id: z46.string().uuid(),
+      backward_moves: z46.number().int()
+    })),
+    avg_backward_moves: z46.number()
+  }),
+  rework: z46.object({
+    total_backward_moves: z46.number().int(),
+    tickets_with_rework: z46.number().int()
+  }),
+  workload: z46.array(z46.object({
+    assignee_id: z46.string().uuid(),
+    completed: z46.number().int(),
+    avg_cycle_time_value: z46.number().nullable()
+  })),
+  wip: z46.object({
+    current_in_progress: z46.number().int()
+  }),
+  time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+});
+var BoardAnalyticsSummarySchema = z46.object({
+  velocity: VelocityResponseSchema,
+  cycle_time: z46.object({
+    avg_value: z46.number(),
+    p85_value: z46.number(),
+    total_completed: z46.number().int(),
+    time_unit: z46.enum(["minutes", "hours", "days"]).default("days")
+  }),
+  wip: z46.object({
+    current: z46.number().int(),
+    limit: z46.number().int().nullable()
+  })
+});
+
+// ../types/dist/pipeline-template.schema.js
+import { z as z47 } from "zod";
+var PipelineTemplateStepSchema = z47.object({
+  name: z47.string(),
+  tool: z47.string(),
+  description: z47.string(),
+  params: z47.record(z47.string(), z47.unknown()),
+  condition: z47.string().optional(),
+  onError: z47.enum(["stop", "skip", "warn"])
+});
+var PipelineTemplateSchema = z47.object({
+  id: z47.string().uuid(),
+  project_id: z47.string().uuid().nullable(),
+  name: z47.string(),
+  display_name: z47.string(),
+  description: z47.string(),
+  steps: z47.array(PipelineTemplateStepSchema),
+  parameters: z47.record(z47.string(), z47.unknown()).default({}),
+  is_builtin: z47.boolean(),
+  created_at: z47.string().datetime({ offset: true }),
+  updated_at: z47.string().datetime({ offset: true })
+});
+var CreatePipelineTemplateBodySchema = z47.object({
+  name: z47.string().min(1).max(100),
+  display_name: z47.string().min(1).max(200),
+  description: z47.string().max(2e3),
+  steps: z47.array(PipelineTemplateStepSchema).min(1),
+  parameters: z47.record(z47.string(), z47.unknown()).optional().default({})
+});
+var UpdatePipelineTemplateBodySchema = z47.object({
+  name: z47.string().min(1).max(100).optional(),
+  display_name: z47.string().min(1).max(200).optional(),
+  description: z47.string().max(2e3).optional(),
+  steps: z47.array(PipelineTemplateStepSchema).min(1).optional(),
+  parameters: z47.record(z47.string(), z47.unknown()).optional()
+});
+var RunPipelineTemplateBodySchema = z47.object({
+  parameters: z47.record(z47.string(), z47.unknown()).optional().default({}),
+  dryRun: z47.boolean().optional().default(true)
+});
+
+// ../types/dist/time-unit.js
+import { z as z48 } from "zod";
+var TimeUnitSchema = z48.enum(["minutes", "hours", "days"]);
+
+// ../types/dist/pipeline-analytics.schema.js
+import { z as z49 } from "zod";
+var PeriodSchema = z49.object({
+  since: z49.string(),
+  until: z49.string()
+});
+var PipelineAnalyticsQuerySchema = z49.object({
+  boardId: z49.string().uuid().optional(),
+  since: z49.string().datetime({ offset: true }).optional(),
+  until: z49.string().datetime({ offset: true }).optional()
+});
+var PipelineAnalyticsResolutionQuerySchema = PipelineAnalyticsQuerySchema.extend({
+  resolution: z49.enum(["auto", "minutes", "hours", "days"]).optional()
+});
+var RunsQuerySchema = z49.object({
+  boardId: z49.string().uuid().optional(),
+  limit: z49.coerce.number().optional().default(10)
+});
+var SessionsQuerySchema = z49.object({
+  boardId: z49.string().uuid().optional(),
+  since: z49.string().datetime({ offset: true }).optional(),
+  limit: z49.coerce.number().optional().default(20)
+});
+var AutonomyResponseSchema = z49.object({
+  total_completed: z49.number(),
+  fully_autonomous: z49.number(),
+  human_assisted: z49.number(),
+  human_only: z49.number(),
+  autonomy_rate: z49.number(),
+  period: PeriodSchema
+});
+var RunSchema = z49.object({
+  started_at: z49.string(),
+  ended_at: z49.string(),
+  tickets_entered: z49.number(),
+  tickets_completed: z49.number(),
+  tickets_escalated: z49.number(),
+  duration_minutes: z49.number()
+});
+var RunsResponseSchema = z49.object({
+  runs: z49.array(RunSchema)
+});
+var SessionSchema = z49.object({
+  session_id: z49.string(),
+  started_at: z49.string(),
+  last_activity_at: z49.string(),
+  action_count: z49.number()
+});
+var SessionsResponseSchema = z49.object({
+  sessions: z49.array(SessionSchema)
+});
+var ThroughputBucketSchema = z49.object({
+  timestamp: z49.string(),
+  autonomous: z49.number(),
+  human_assisted: z49.number(),
+  human_only: z49.number(),
+  escalated: z49.number()
+});
+var ThroughputResponseSchema = z49.object({
+  buckets: z49.array(ThroughputBucketSchema),
+  time_unit: TimeUnitSchema,
+  period: PeriodSchema
+});
+
+// ../types/dist/ticket-transition.schema.js
+import { z as z50 } from "zod";
+var TransitionQuerySchema = z50.object({
+  limit: z50.coerce.number().int().min(1).max(100).default(20)
+});
+var TicketTransitionSchema = z50.object({
+  id: z50.string().uuid(),
+  project_id: z50.string().uuid(),
+  board_id: z50.string().uuid(),
+  ticket_id: z50.string().uuid(),
+  from_column: z50.string().uuid().nullable(),
+  to_column: z50.string().uuid(),
+  moved_by: z50.string().uuid().nullable(),
+  handoff: z50.record(z50.string(), z50.unknown()).nullable().default(null),
+  created_at: z50.string().datetime({ offset: true })
+});
+var TicketTransitionWithColumnsSchema = TicketTransitionSchema.extend({
+  from_column_name: z50.string().nullable().optional(),
+  to_column_name: z50.string().nullable().optional()
+});
+
+// ../types/dist/pipeline-context.schema.js
+import { z as z51 } from "zod";
+var AdvisorConfigSchema = z51.object({
+  enabled: z51.boolean(),
+  max_invocations: z51.number().int().positive().optional(),
+  model: z51.string().optional()
+});
+var ModelRoutingSchema = z51.object({
+  initial: z51.string(),
+  escalation: z51.array(z51.string()).min(1),
+  escalate_after: z51.number().int().positive().optional()
+});
+var StuckDetectionConfigSchema = z51.object({
+  enabled: z51.boolean(),
+  first_check: z51.number().int().positive().optional(),
+  interval: z51.number().int().positive().optional()
+});
+var AgentConfigSchema = z51.object({
+  execution_mode: z51.enum(["kant_loop", "cron_poll", "manual"]).optional(),
+  model_preference: z51.string().optional(),
+  max_iterations: z51.number().int().positive().optional(),
+  max_budget_usd: z51.number().positive().nullable().optional(),
+  concurrency: z51.number().int().positive().optional(),
+  gutter_threshold: z51.number().int().positive().optional(),
+  poll_interval_seconds: z51.number().int().positive().optional(),
+  worktree: z51.object({
+    enabled: z51.boolean(),
+    path_pattern: z51.string().optional(),
+    // legacy — still accepted, ignored by orchestrator
+    on_move: z51.enum(["keep", "merge", "cleanup"]).optional(),
+    on_done: z51.enum(["pr", "merge", "cleanup"]).optional(),
+    integration_branch: z51.string().optional()
+  }).optional(),
+  invocation_tier: z51.enum(["auto", "light", "heavy"]).optional(),
+  run_memory: z51.boolean().optional(),
+  lookahead_column_id: z51.string().uuid().optional(),
+  advisor: AdvisorConfigSchema.optional(),
+  checkpoint: z51.boolean().optional(),
+  model_routing: ModelRoutingSchema.optional(),
+  builtin_tools: z51.string().optional(),
+  // Value for --tools flag: space-separated list, '' to strip all
+  allowed_tools: z51.array(z51.string()).optional(),
+  disallowed_tools: z51.array(z51.string()).optional(),
+  stuck_detection: StuckDetectionConfigSchema.optional(),
+  extensions: z51.record(z51.string(), z51.unknown()).optional()
+}).strict();
+var TicketFingerprintSchema = z51.object({
+  column_id: z51.string().uuid().nullable(),
+  updated_at: z51.string().datetime({ offset: true }),
+  comment_count: z51.number(),
+  signal_count: z51.number(),
+  field_value_count: z51.number()
+});
+var DebtItemSchema = z51.object({
+  type: z51.enum(["dropped_criterion", "missing_test", "missing_functionality", "unmet_requirement", "waived_gate"]),
+  description: z51.string(),
+  severity: z51.enum(["high", "medium", "low"]),
+  source_column: z51.string().optional()
+});
+var LoopCheckpointSchema = z51.object({
+  run_id: z51.string().uuid(),
+  column_id: z51.string().uuid(),
+  iteration: z51.number().int().nonnegative(),
+  gutter_count: z51.number().int().nonnegative(),
+  advisor_invocations: z51.number().int().nonnegative(),
+  model_tier: z51.string(),
+  last_fingerprint: TicketFingerprintSchema.optional(),
+  worktree_name: z51.string().optional(),
+  updated_at: z51.string().datetime({ offset: true })
+});
+var PipelineContextBoardScopeSchema = z51.object({
+  scope: z51.literal("board"),
+  board: z51.object({
+    id: z51.string().uuid(),
+    name: z51.string()
+  }),
+  backlog_ticket_count: z51.number().int(),
+  columns: z51.array(z51.object({
+    id: z51.string().uuid(),
+    name: z51.string(),
+    type: z51.string(),
+    position: z51.number().int(),
+    wip_limit: z51.number().int().nullable(),
+    goal: z51.string().nullable().optional(),
+    ticket_count: z51.number().int(),
+    has_prompt: z51.boolean(),
+    constraint_count: z51.number().int().nonnegative().optional()
+  })),
+  circuit_breaker: z51.object({
+    threshold: z51.number().int().nullable(),
+    target_column_id: z51.string().uuid().nullable()
+  }).nullable(),
+  tool_prefix: z51.string(),
+  board_constraint_count: z51.number().int().nonnegative().optional()
+});
+var PipelineContextColumnScopeSchema = z51.object({
+  scope: z51.literal("column"),
+  column: z51.object({
+    id: z51.string().uuid(),
+    name: z51.string(),
+    goal: z51.string().nullable().optional()
+  }),
+  prompt_document: z51.object({
+    id: z51.string().uuid(),
+    title: z51.string(),
+    content: z51.string()
+  }).nullable().optional(),
+  agent_config: z51.record(z51.string(), z51.unknown()).nullable().optional(),
+  tickets: z51.array(z51.object({
+    id: z51.string().uuid(),
+    ticket_number: z51.number().int(),
+    title: z51.string(),
+    assignee_name: z51.string().nullable(),
+    backward_transitions: z51.number().int().optional()
+  })),
+  transition_rules: z51.string().nullable(),
+  signals: z51.array(z51.string()),
+  field_definitions: z51.array(z51.object({
+    id: z51.string().uuid(),
+    name: z51.string(),
+    type: z51.string()
+  })),
+  tool_prefix: z51.string(),
+  firing_constraints: z51.array(z51.object({
+    id: z51.string().uuid(),
+    name: z51.string(),
+    enabled: z51.boolean(),
+    subject_type: FiringConstraintSubjectTypeSchema,
+    subject_ref: z51.string(),
+    operator: FiringConstraintOperatorSchema,
+    value: z51.unknown(),
+    scope: z51.string(),
+    notify: z51.boolean(),
+    column_id: z51.string().uuid().nullable()
+  })).optional()
+});
+var PipelineContextTicketScopeSchema = z51.object({
+  scope: z51.literal("ticket"),
+  ticket: z51.object({
+    id: z51.string().uuid(),
+    ticket_number: z51.number().int(),
+    title: z51.string(),
+    description: z51.string().nullable(),
+    backward_transitions: z51.number().int(),
+    assignee: z51.object({
+      id: z51.string().uuid(),
+      name: z51.string()
+    }).nullable(),
+    column: z51.object({
+      id: z51.string().uuid(),
+      name: z51.string(),
+      type: z51.string()
+    }).nullable()
+  }),
+  field_values: z51.array(z51.object({
+    field_name: z51.string(),
+    value: z51.unknown()
+  })),
+  transitions: z51.array(z51.object({
+    from: z51.string().nullable(),
+    to: z51.string(),
+    handoff: z51.record(z51.string(), z51.unknown()).nullable(),
+    timestamp: z51.string()
+  })),
+  comments: z51.array(z51.object({
+    author: z51.string(),
+    body: z51.string(),
+    created_at: z51.string()
+  })),
+  ticket_links: z51.array(z51.object({
+    direction: z51.enum(["outward", "inward"]),
+    link_type: z51.enum(["blocks", "relates_to", "duplicates"]),
+    ticket_id: z51.string().uuid(),
+    ticket_number: z51.number().int(),
+    title: z51.string(),
+    column_name: z51.string().nullable(),
+    resolved: z51.boolean()
+  })),
+  parent: z51.object({
+    id: z51.string().uuid(),
+    ticket_number: z51.number().int(),
+    title: z51.string()
+  }).nullable(),
+  children: z51.array(z51.object({
+    id: z51.string().uuid(),
+    ticket_number: z51.number().int(),
+    title: z51.string(),
+    column_name: z51.string().nullable()
+  })),
+  signals: z51.array(z51.string()),
+  linked_documents: z51.array(z51.object({
+    id: z51.string().uuid(),
+    title: z51.string(),
+    content: z51.string().optional(),
+    truncated: z51.boolean().optional()
+  })),
+  transition_rules: z51.string().nullable(),
+  dependency_requirements: z51.string(),
+  tool_prefix: z51.string()
+});
+var PipelineContextResponseSchema = z51.discriminatedUnion("scope", [
+  PipelineContextBoardScopeSchema,
+  PipelineContextColumnScopeSchema,
+  PipelineContextTicketScopeSchema
+]);
+
+// ../types/dist/gate.schema.js
+import { z as z52 } from "zod";
+var GateResultSchema = z52.object({
+  name: z52.string(),
+  passed: z52.boolean(),
+  required: z52.boolean(),
+  duration_ms: z52.number().int().nonnegative(),
+  output: z52.string().max(1048576),
+  stderr: z52.string(),
+  exit_code: z52.number().int().min(0).max(255),
+  timed_out: z52.boolean()
+});
+var GateDeltaSchema = z52.enum(["improved", "same", "regressed", "first_check"]);
+var GateSnapshotSchema = z52.object({
+  timestamp: z52.string().datetime({ offset: true }),
+  iteration: z52.number().int().nonnegative(),
+  results: z52.array(GateResultSchema),
+  all_required_passed: z52.boolean(),
+  delta_from_previous: GateDeltaSchema
+});
+var GateDefinitionSchema = z52.object({
+  name: z52.string().min(1),
+  run: z52.string().min(1),
+  required: z52.boolean().default(true),
+  timeout: z52.string().regex(/^\d+(s|m)$/, 'Must be format like "60s" or "5m"').optional()
+});
+var ColumnGateOverrideSchema = z52.object({
+  extend: z52.boolean().default(true),
+  gates: z52.array(GateDefinitionSchema).default([])
+});
+var BudgetConfigSchema = z52.object({
+  max_input_tokens: z52.number().int().positive(),
+  max_output_tokens: z52.number().int().positive(),
+  warn_pct: z52.number().int().min(1).max(100).default(75)
+});
+var PricingEntrySchema = z52.object({
+  input_per_mtok: z52.number().nonnegative(),
+  output_per_mtok: z52.number().nonnegative()
+});
+var GateSettingsSchema = z52.object({
+  cwd: z52.string().optional(),
+  env: z52.record(z52.string(), z52.string()).optional(),
+  total_timeout: z52.string().optional(),
+  budget: BudgetConfigSchema.optional(),
+  pricing: z52.record(z52.string(), PricingEntrySchema).optional()
+});
+var GateConfigSchema = z52.object({
+  default: z52.array(GateDefinitionSchema),
+  columns: z52.record(z52.string(), ColumnGateOverrideSchema).optional(),
+  settings: GateSettingsSchema.optional()
+});
+var VerdictFindingSchema = z52.object({
+  severity: z52.enum(["blocker", "warning", "nit"]),
+  file: z52.string().optional(),
+  line: z52.number().int().positive().optional(),
+  description: z52.string()
+});
+var VerdictSchema = z52.object({
+  decision: z52.enum(["approve", "reject"]),
+  summary: z52.string(),
+  findings: z52.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;
+}
+
+// src/lib/prompt-composer.ts
+var PROMPT_BUDGETS = {
+  system_preamble: 800,
+  gate_results: 500,
+  column_prompt: Infinity,
+  // NEVER truncated
+  lookahead: 1e3,
+  run_memory: 1e3,
+  rejection: 500,
+  ticket_details: 1500,
+  comments: 2e3,
+  transition_rules: 500,
+  linked_documents: 2e3,
+  metadata: 200
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokens(text, maxTokens) {
+  if (maxTokens === Infinity) return text;
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n[...truncated]";
+}
+function windowComments(comments, maxTokens) {
+  const pinned = comments.filter((c) => c.pinned);
+  const unpinned = comments.filter((c) => !c.pinned);
+  const recentFull = unpinned.slice(-3);
+  const older = unpinned.slice(0, -3);
+  const parts = [];
+  for (const c of pinned) {
+    parts.push(`[pinned] **${c.author}** (${c.created_at}):
+${c.body}
+`);
+  }
+  for (const c of recentFull) {
+    parts.push(`**${c.author}** (${c.created_at}):
+${c.body}
+`);
+  }
+  for (const c of older) {
+    const firstLine = c.body.split("\n")[0]?.slice(0, 100) ?? "";
+    parts.push(`- ${c.author}: ${firstLine}`);
+  }
+  const joined = parts.join("\n");
+  return truncateToTokens(joined, maxTokens);
+}
+function composePrompt(columnContext, ticketContext, meta) {
+  const parts = [];
+  if (!columnContext.prompt_document?.content) {
+    throw new Error(
+      `Column "${columnContext.column.name}" has no prompt document. Configure a prompt document for this column before running the pipeline.`
+    );
+  }
+  const hasUnresolvedBlockers = ticketContext.ticket_links.some(
+    (l) => l.direction === "inward" && l.link_type === "blocks" && !l.resolved
+  );
+  parts.push(`# Pipeline Agent Instructions
+
+You are a pipeline automation agent processing ticket #${String(ticketContext.ticket.ticket_number)}: "${ticketContext.ticket.title}".
+
+## Your Goal
+Advance this ticket through the pipeline. Your success criteria:
+1. Complete the work described in the ticket and column prompt below
+2. Move the ticket to the next column using \`${ticketContext.tool_prefix}move_ticket\`
+3. Or mark it complete using \`${ticketContext.tool_prefix}complete_task\`
+
+## Iteration ${meta.iteration} of ${meta.maxIterations}
+${meta.iteration >= meta.maxIterations - 1 ? "**FINAL ITERATIONS** \u2014 prioritize moving the ticket NOW or it will be marked stalled." : `You have ${meta.maxIterations - meta.iteration} iterations remaining. Make meaningful progress each iteration.`}
+${meta.gutterCount > 0 ? `
+## Progress Warning
+No meaningful progress detected for ${meta.gutterCount} consecutive iteration(s).
+${meta.gutterThreshold - meta.gutterCount} iteration(s) remain before this loop is terminated as stalled.
+
+You MUST change approach. What you've been doing is not working. Consider:
+- Breaking the problem into smaller steps
+- Setting a field value to record partial progress
+- Creating a comment explaining what's blocking you
+- Asking for help via a signal
+` : ""}
+## Available Tools (prefix: ${ticketContext.tool_prefix})
+- **${ticketContext.tool_prefix}check_transition** \u2014 ALWAYS call this before moving. Returns allowed/blocked with recovery steps.
+  Params: \`{ projectId, boardId, ticketId, targetColumnId }\`
+- **${ticketContext.tool_prefix}move_ticket** \u2014 Move ticket to a new column. Include handoff data for the next agent.
+  Params: \`{ projectId, ticketId, column_id, handoff: { branch?, commit_sha?, build_status?, notes? } }\`
+- **${ticketContext.tool_prefix}complete_task** \u2014 Move to a done column with handoff data.
+  Params: \`{ projectId, ticketId, handoff: { ... } }\`
+- **${ticketContext.tool_prefix}set_field_value** \u2014 Set a required field before moving (check transition rules).
+  Params: \`{ projectId, ticketId, fieldId, value }\`
+- **${ticketContext.tool_prefix}create_signal** \u2014 Leave knowledge for future agents at any scope.
+- **${ticketContext.tool_prefix}create_comment** \u2014 Add progress notes to the ticket.
+- **${ticketContext.tool_prefix}append_run_memory** \u2014 Share discoveries with future agents.
+  Params: \`{ section: 'conventions'|'interfaces'|'failures'|'decisions', content: string }\`
+
+## Iteration Summary
+If you made meaningful progress this iteration, create a comment using \`${ticketContext.tool_prefix}create_comment\` summarizing:
+- What you accomplished
+- What remains to be done
+- Any blockers or issues encountered
+
+This comment is your handoff to the next iteration. Without it, the next iteration starts blind.
+
+## Critical Rules
+1. **Always call ${ticketContext.tool_prefix}check_transition before ${ticketContext.tool_prefix}move_ticket** \u2014 moves that violate workflow rules will fail.
+2. **If the ticket has UNRESOLVED blockers, do not attempt to move it.** Create a comment explaining you are waiting, then stop.
+3. **Include handoff data** when moving \u2014 the next agent needs context (branch name, build status, etc.).
+4. **If you cannot make progress**, create a comment explaining why and stop. Do not burn iterations.
+${hasUnresolvedBlockers ? "\n**WARNING: This ticket has UNRESOLVED blockers. Do NOT attempt to move it. Document your status and stop.**\n" : ""}
+---
+`);
+  const worktreeConfig = columnContext.agent_config?.worktree;
+  if (worktreeConfig?.enabled) {
+    const integrationBranch = worktreeConfig.integration_branch ?? "main";
+    if (!VALID_BRANCH_RE.test(integrationBranch)) {
+      parts.push(`## Git Worktree
+
+You are working in an isolated git worktree. Integration branch name is invalid \u2014 contact the pipeline operator.`);
+    } else {
+      parts.push(`## Git Worktree
+
+You are working in an isolated git worktree. Before starting any code changes:
+1. Merge \`${integrationBranch}\` into your current branch: \`git merge '${integrationBranch}'\`
+2. Resolve any merge conflicts before proceeding with ticket work
+3. Never rebase \u2014 always merge (rebase destroys traceability across the pipeline)
+
+After completing your work, commit all changes to your worktree branch.
+`);
+    }
+  }
+  if (ticketContext.signals.length > 0) {
+    parts.push(`
+## Signals (Guardrails)
+`);
+    for (const s of ticketContext.signals) {
+      parts.push(`- ${s}`);
+    }
+  }
+  if (meta.gateResults && meta.gateResults.length > 0) {
+    parts.push(`
+## Previous Gate Results
+`);
+    for (const r of meta.gateResults) {
+      const status = r.passed ? "PASS" : "FAIL";
+      const req = r.required ? "(required)" : "(advisory)";
+      parts.push(`- **${r.name}** ${status} ${req} [${String(r.duration_ms)}ms]`);
+      if (!r.passed && r.output) {
+        parts.push(`  \`\`\`
+  ${truncateToTokens(r.output, 200)}
+  \`\`\``);
+      }
+    }
+  }
+  if (meta.rejectionFindings) {
+    parts.push(`
+## Previous Rejection (fix these before resubmitting)
+`);
+    parts.push(truncateToTokens(meta.rejectionFindings, PROMPT_BUDGETS.rejection));
+  } else {
+    const rejectionComment = ticketContext.comments.slice().reverse().find((c) => c.body.startsWith("QA REJECTION:") || c.body.startsWith("REJECTION:"));
+    if (rejectionComment) {
+      parts.push(`
+## Previous Rejection (fix these before resubmitting)
+`);
+      parts.push(truncateToTokens(rejectionComment.body, PROMPT_BUDGETS.rejection));
+    }
+  }
+  if (columnContext.prompt_document?.content) {
+    parts.push(columnContext.prompt_document.content);
+  }
+  if (meta.lookaheadDocument?.content) {
+    parts.push(`
+## Downstream Criteria (build to pass these)
+`);
+    parts.push(`*From: ${meta.lookaheadDocument.title}*
+`);
+    parts.push(truncateToTokens(meta.lookaheadDocument.content, PROMPT_BUDGETS.lookahead));
+  }
+  if (meta.runMemoryContent) {
+    parts.push(`
+## Run Memory
+`);
+    parts.push(truncateToTokens(meta.runMemoryContent, PROMPT_BUDGETS.run_memory));
+    parts.push(`
+You can contribute to run memory using ${ticketContext.tool_prefix}append_run_memory.`);
+  }
+  parts.push(`## Current Ticket
+`);
+  parts.push(`**Title:** ${ticketContext.ticket.title}`);
+  parts.push(`**Ticket ID:** ${ticketContext.ticket.id}`);
+  parts.push(`**Ticket Number:** ${String(ticketContext.ticket.ticket_number)}`);
+  if (ticketContext.ticket.description) {
+    parts.push(`
+${truncateToTokens(ticketContext.ticket.description, PROMPT_BUDGETS.ticket_details)}`);
+  }
+  if (ticketContext.ticket.assignee) {
+    parts.push(`**Assignee:** ${ticketContext.ticket.assignee.name}`);
+  }
+  if (ticketContext.ticket.column) {
+    parts.push(`**Current Column:** ${ticketContext.ticket.column.name} (${ticketContext.ticket.column.type})`);
+  }
+  if (ticketContext.ticket.backward_transitions > 0) {
+    parts.push(`**Backward Transitions:** ${String(ticketContext.ticket.backward_transitions)}`);
+  }
+  if (ticketContext.field_values.length > 0) {
+    parts.push(`
+## Field Values
+`);
+    for (const fv of ticketContext.field_values) {
+      parts.push(`- **${fv.field_name}:** ${fv.value !== null ? JSON.stringify(fv.value) : "(not set)"}`);
+    }
+  }
+  if (ticketContext.parent) {
+    parts.push(`
+## Parent Ticket
+`);
+    parts.push(`- #${String(ticketContext.parent.ticket_number)}: ${ticketContext.parent.title}`);
+  }
+  if (ticketContext.children.length > 0) {
+    parts.push(`
+## Child Tickets
+`);
+    for (const child of ticketContext.children) {
+      parts.push(`- #${String(child.ticket_number)}: ${child.title}${child.column_name ? ` (${child.column_name})` : ""}`);
+    }
+  }
+  if (ticketContext.transitions.length > 0) {
+    parts.push(`
+## Transition History
+`);
+    let transitionTokens = 0;
+    const TRANSITION_BUDGET = 1e3;
+    for (const t of ticketContext.transitions) {
+      let line = `- ${t.from ?? "Backlog"} \u2192 ${t.to}`;
+      if (t.handoff) line += ` (handoff: ${JSON.stringify(t.handoff)})`;
+      const lineTokens = estimateTokens(line);
+      if (transitionTokens + lineTokens > TRANSITION_BUDGET) {
+        parts.push(`- [...truncated \u2014 ${String(ticketContext.transitions.length)} total transitions]`);
+        break;
+      }
+      parts.push(line);
+      transitionTokens += lineTokens;
+    }
+  }
+  if (ticketContext.ticket_links.length > 0) {
+    parts.push(`
+## Ticket Links
+`);
+    const blockers = ticketContext.ticket_links.filter((l) => l.direction === "inward" && l.link_type === "blocks");
+    const blocking = ticketContext.ticket_links.filter((l) => l.direction === "outward" && l.link_type === "blocks");
+    const related = ticketContext.ticket_links.filter((l) => l.link_type === "relates_to");
+    if (blockers.length > 0) {
+      parts.push(`**Blocked by:**`);
+      for (const l of blockers) {
+        const status = l.resolved ? "(resolved)" : "UNRESOLVED";
+        parts.push(`- #${String(l.ticket_number)}: ${l.title} [${l.column_name ?? "backlog"}] ${status}`);
+      }
+    }
+    if (blocking.length > 0) {
+      parts.push(`**Blocks:**`);
+      for (const l of blocking) {
+        parts.push(`- #${String(l.ticket_number)}: ${l.title} [${l.column_name ?? "backlog"}]`);
+      }
+    }
+    if (related.length > 0) {
+      parts.push(`**Related:**`);
+      for (const l of related) {
+        parts.push(`- #${String(l.ticket_number)}: ${l.title}`);
+      }
+    }
+  }
+  if (ticketContext.comments.length > 0) {
+    parts.push(`
+## Comments
+`);
+    parts.push(windowComments(ticketContext.comments, PROMPT_BUDGETS.comments));
+  }
+  if (ticketContext.transition_rules) {
+    parts.push(`
+## Transition Rules
+`);
+    parts.push(truncateToTokens(ticketContext.transition_rules, PROMPT_BUDGETS.transition_rules));
+  }
+  if (ticketContext.dependency_requirements && ticketContext.dependency_requirements !== "No dependency or field requirements configured.") {
+    parts.push(`
+## Dependency & Field Requirements
+`);
+    parts.push(ticketContext.dependency_requirements);
+  }
+  if (ticketContext.linked_documents.length > 0) {
+    parts.push(`
+## Linked Documents
+`);
+    let remainingTokens = PROMPT_BUDGETS.linked_documents;
+    for (const doc of ticketContext.linked_documents) {
+      if (doc.content) {
+        const docHeader = `### ${doc.title}
+`;
+        const headerTokens = estimateTokens(docHeader);
+        const contentTokens = estimateTokens(doc.content);
+        if (headerTokens + contentTokens <= remainingTokens) {
+          parts.push(docHeader);
+          parts.push(doc.content);
+          remainingTokens -= headerTokens + contentTokens;
+        } else if (remainingTokens > headerTokens + 50) {
+          parts.push(docHeader);
+          parts.push(truncateToTokens(doc.content, remainingTokens - headerTokens));
+          remainingTokens = 0;
+        } else {
+          parts.push(`- ${doc.title} (truncated \u2014 token budget exceeded)`);
+          remainingTokens = 0;
+        }
+      } else if (doc.truncated) {
+        parts.push(`- ${doc.title} (document too large \u2014 read via kantban_get_document)`);
+      }
+      if (remainingTokens <= 0) break;
+    }
+  }
+  parts.push(`
+## Pipeline Metadata
+`);
+  parts.push(`- Iteration: ${meta.iteration} / ${meta.maxIterations}`);
+  parts.push(`- Project ID: ${meta.projectId}`);
+  parts.push(`- Tool Prefix: ${ticketContext.tool_prefix}`);
+  parts.push(`- Column: ${columnContext.column.name}`);
+  parts.push(`- Goal: ${columnContext.column.goal ?? "No goal set"}`);
+  return parts.join("\n");
+}
+
+// src/lib/ralph-loop.ts
+var API_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise.finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    })
+  ]);
+}
+var RalphLoop = class {
+  ticketId;
+  columnId;
+  config;
+  deps;
+  stopped = false;
+  currentIteration = 0;
+  constructor(ticketId, columnId, config, deps) {
+    this.ticketId = ticketId;
+    this.columnId = columnId;
+    this.config = config;
+    this.deps = deps;
+  }
+  stop() {
+    this.stopped = true;
+  }
+  get iteration() {
+    return this.currentIteration;
+  }
+  looksLike404(err) {
+    const statusCode = err?.statusCode ?? err?.status;
+    if (statusCode === 404) return true;
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes("API error 404");
+  }
+  async run() {
+    let gutterCount = this.config.startGutterCount ?? 0;
+    let lastFingerprint = this.config.startFingerprint ?? null;
+    const log = this.deps.log ?? (() => {
+    });
+    const resolvedModel = this.config.model ?? "default";
+    const gateSnapshots = [];
+    let cumulativeTokensIn = 0;
+    let cumulativeTokensOut = 0;
+    let cumulativeToolCalls = 0;
+    let cumulativeDurationMs = 0;
+    const withCosts = (r) => ({
+      ...r,
+      tokensIn: cumulativeTokensIn,
+      tokensOut: cumulativeTokensOut,
+      toolCallCount: cumulativeToolCalls,
+      durationMs: cumulativeDurationMs
+    });
+    let lastOutput = "";
+    const startIter = this.config.startIteration ?? 1;
+    for (let i = startIter; i <= this.config.maxIterations; i++) {
+      if (this.stopped) return withCosts({ reason: "stopped", iterations: i - 1, gutterCount, model: resolvedModel });
+      this.currentIteration = i;
+      log(`Iteration ${i}/${this.config.maxIterations} starting`);
+      if (!lastFingerprint) {
+        try {
+          lastFingerprint = await withTimeout(
+            this.deps.fetchFingerprint(this.ticketId),
+            API_TIMEOUT_MS,
+            "fetchFingerprint (baseline)"
+          );
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Baseline fingerprint fetch failed: ${message}`);
+          if (this.looksLike404(err)) {
+            return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+          }
+          return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Baseline fingerprint failed: ${message}`, model: resolvedModel });
+        }
+      }
+      let ticketCtx;
+      let columnCtx;
+      try {
+        [ticketCtx, columnCtx] = await Promise.all([
+          withTimeout(this.deps.fetchTicketContext(this.ticketId), API_TIMEOUT_MS, "fetchTicketContext"),
+          withTimeout(this.deps.fetchColumnContext(this.columnId), API_TIMEOUT_MS, "fetchColumnContext")
+        ]);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Context fetch failed: ${message}`);
+        if (this.looksLike404(err)) {
+          return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+        }
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Context fetch failed: ${message}`, model: resolvedModel });
+      }
+      if (ticketCtx.ticket.column && ticketCtx.ticket.column.id !== this.columnId) {
+        log(`Ticket already in column ${ticketCtx.ticket.column.name}, not ${this.columnId} \u2014 exiting as moved`);
+        return withCosts({ reason: "moved", iterations: i - 1, gutterCount, model: resolvedModel });
+      }
+      const runMemoryContent = this.deps.fetchRunMemoryContent ? await this.deps.fetchRunMemoryContent().catch(() => "") : void 0;
+      const lookaheadDocument = this.deps.fetchLookaheadDocument ? await this.deps.fetchLookaheadDocument().catch(() => void 0) : void 0;
+      let prompt;
+      try {
+        prompt = composePrompt(columnCtx, ticketCtx, {
+          iteration: i,
+          maxIterations: this.config.maxIterations,
+          projectId: this.deps.projectId,
+          gutterCount,
+          gutterThreshold: this.config.gutterThreshold,
+          runMemoryContent: runMemoryContent || void 0,
+          lookaheadDocument
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Prompt composition failed: ${message}`);
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Prompt composition failed: ${message}`, model: resolvedModel });
+      }
+      if (this.stopped) return withCosts({ reason: "stopped", iterations: i - 1, gutterCount, model: resolvedModel });
+      log(`Invoking Claude (model=${this.config.model ?? "default"})`);
+      const iterationRunId = `${this.config.runId ?? this.ticketId}-iter-${String(i)}`;
+      const iterationStart = Date.now();
+      this.deps.onSessionStart?.({
+        runId: iterationRunId,
+        model: this.config.model ?? "default",
+        iteration: i
+      });
+      const streamContext = { runId: iterationRunId, ticketId: this.ticketId, columnId: this.columnId };
+      const { exitCode, output, toolCallCount, tokensIn, tokensOut } = await this.deps.invokeClaudeP(prompt, {
+        mcpConfigPath: this.deps.mcpConfigPath,
+        model: this.config.model,
+        maxBudgetUsd: this.config.maxBudgetUsd,
+        worktree: this.config.worktreeName,
+        onStreamEvent: (event) => this.deps.onStreamEvent?.(event, streamContext),
+        // Tool scoping
+        ...this.config.toolRestrictions && {
+          tools: this.config.toolRestrictions.tools,
+          allowedTools: this.config.toolRestrictions.allowedTools,
+          disallowedTools: this.config.toolRestrictions.disallowedTools,
+          includeMcpConfig: this.config.toolRestrictions.includeMcpConfig
+        }
+      });
+      const iterationDurationMs = Date.now() - iterationStart;
+      cumulativeTokensIn += tokensIn;
+      cumulativeTokensOut += tokensOut;
+      cumulativeToolCalls += toolCallCount;
+      cumulativeDurationMs += iterationDurationMs;
+      this.deps.onSessionEnd?.({
+        runId: iterationRunId,
+        exitCode,
+        tokensIn,
+        tokensOut,
+        toolCallCount,
+        durationMs: iterationDurationMs
+      });
+      if (exitCode !== 0) {
+        const snippet = output.slice(-200);
+        log(`Claude exited with code ${exitCode}: ${snippet}`);
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `non-zero exit code: ${exitCode}. Last output: ${snippet}`, model: resolvedModel });
+      }
+      log(`Claude exited successfully`);
+      lastOutput = output;
+      let afterFp;
+      try {
+        const retryDelayMs = this.config.postMoveRetryDelayMs ?? 1500;
+        afterFp = await withTimeout(
+          this.deps.fetchFingerprint(this.ticketId),
+          API_TIMEOUT_MS,
+          "fetchFingerprint (post-iteration)"
+        );
+        if (afterFp.column_id === this.columnId) {
+          for (let retry = 0; retry < 2; retry++) {
+            await new Promise((r) => setTimeout(r, retryDelayMs));
+            if (this.stopped) break;
+            try {
+              afterFp = await withTimeout(
+                this.deps.fetchFingerprint(this.ticketId),
+                API_TIMEOUT_MS,
+                "fetchFingerprint (retry)"
+              );
+            } catch (err) {
+              log(`Fingerprint retry ${retry + 1} failed: ${err instanceof Error ? err.message : String(err)} \u2014 using last good value`);
+              break;
+            }
+            if (afterFp.column_id !== this.columnId) break;
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Post-iteration fingerprint failed: ${message}`);
+        if (this.looksLike404(err)) {
+          return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+        }
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Post-iteration fingerprint failed: ${message}`, model: resolvedModel });
+      }
+      if (afterFp.column_id !== this.columnId) {
+        log(`Ticket moved to column ${afterFp.column_id ?? "null"}`);
+        return withCosts({ reason: "moved", iterations: i, gutterCount, model: resolvedModel, output: lastOutput });
+      }
+      if (this.config.onPostIterationGates) {
+        try {
+          const snapshot = await this.config.onPostIterationGates(this.ticketId, i);
+          gateSnapshots.push(snapshot);
+          const fieldDelta = lastFingerprint ? afterFp.field_value_count !== lastFingerprint.field_value_count : false;
+          switch (snapshot.delta_from_previous) {
+            case "improved":
+              if (gutterCount > 0) log(`Gate improvement detected \u2014 gutter counter reset`);
+              gutterCount = 0;
+              break;
+            case "same":
+              if (!fieldDelta) {
+                gutterCount++;
+                log(`No gate progress (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+              } else {
+                log(`Gates unchanged but fields changed \u2014 not incrementing gutter`);
+              }
+              break;
+            case "regressed":
+              gutterCount += 2;
+              log(`Gate regression detected (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+              break;
+            case "first_check":
+              break;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Post-iteration gate check failed (non-blocking): ${message}`);
+          if (lastFingerprint && fingerprintsMatch(lastFingerprint, afterFp)) {
+            gutterCount++;
+            log(`No progress detected via fingerprint fallback (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+          } else {
+            if (gutterCount > 0) log(`Progress detected \u2014 gutter counter reset`);
+            gutterCount = 0;
+          }
+        }
+      } else {
+        if (lastFingerprint && fingerprintsMatch(lastFingerprint, afterFp)) {
+          gutterCount++;
+          log(`No progress detected (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+        } else {
+          if (gutterCount > 0) log(`Progress detected \u2014 gutter counter reset`);
+          gutterCount = 0;
+        }
+      }
+      lastFingerprint = afterFp;
+      if (this.config.stuckDetection && shouldCheckStuckDetection(this.config.stuckDetection, i)) {
+        try {
+          let sdStatus;
+          let sdEvidence;
+          let sdConfidence;
+          if (gateSnapshots.length > 0) {
+            const trajectory = classifyTrajectory(gateSnapshots);
+            sdStatus = trajectory.status === "regressing" ? "spinning" : trajectory.status;
+            sdEvidence = trajectory.evidence;
+            sdConfidence = trajectory.confidence;
+            log(`Gate-based stuck detection: ${sdStatus} (confidence=${String(sdConfidence)}) \u2014 ${sdEvidence}`);
+          } else if (this.config.invokeStuckDetection) {
+            const sdInput = {
+              ticketNumber: ticketCtx.ticket.ticket_number,
+              ticketTitle: ticketCtx.ticket.title,
+              columnName: columnCtx.column.name,
+              iteration: i,
+              maxIterations: this.config.maxIterations,
+              recentComments: ticketCtx.comments.slice(-3).map((c) => ({
+                author: c.author,
+                body: c.body
+              }))
+            };
+            const sdResult = await this.config.invokeStuckDetection(sdInput);
+            sdStatus = sdResult.status;
+            sdEvidence = sdResult.evidence;
+            sdConfidence = sdResult.confidence;
+            log(`Stuck detection: ${sdStatus} (confidence=${String(sdConfidence)}) \u2014 ${sdEvidence}`);
+          } else {
+            sdStatus = "progressing";
+            sdEvidence = "no detection method";
+            sdConfidence = 0;
+          }
+          switch (sdStatus) {
+            case "progressing":
+              if (gutterCount > 0) {
+                log(`Stuck detection override: resetting gutter counter (was ${String(gutterCount)})`);
+                gutterCount = 0;
+              }
+              break;
+            case "spinning":
+              gutterCount += 2;
+              log(`Stuck detection: spinning \u2014 gutter accelerated to ${String(gutterCount)}/${String(this.config.gutterThreshold)}`);
+              break;
+            case "blocked":
+              log(`Stuck detection: blocked \u2014 exiting immediately`);
+              return withCosts({
+                reason: "stalled",
+                iterations: i,
+                gutterCount: this.config.gutterThreshold,
+                model: resolvedModel,
+                output: lastOutput,
+                ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+              });
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Stuck detection failed (non-blocking): ${message}`);
+        }
+      }
+      if (gutterCount >= this.config.gutterThreshold) {
+        return withCosts({
+          reason: "stalled",
+          iterations: i,
+          gutterCount,
+          model: resolvedModel,
+          output: lastOutput,
+          ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+        });
+      }
+      if (this.config.onCheckpoint) {
+        try {
+          await this.config.onCheckpoint(this.ticketId, {
+            run_id: this.config.runId ?? "00000000-0000-0000-0000-000000000000",
+            column_id: this.columnId,
+            iteration: i,
+            gutter_count: gutterCount,
+            advisor_invocations: 0,
+            // tracked by orchestrator, not loop
+            model_tier: resolvedModel,
+            last_fingerprint: afterFp,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+            worktree_name: this.config.worktreeName
+          });
+        } catch (err) {
+          log(`Checkpoint write failed (non-blocking): ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    return withCosts({
+      reason: "max_iterations",
+      iterations: this.config.maxIterations,
+      gutterCount,
+      model: resolvedModel,
+      output: lastOutput,
+      ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+    });
+  }
+};
+function fingerprintsMatch(a, b) {
+  return a.column_id === b.column_id && a.field_value_count === b.field_value_count && a.comment_count === b.comment_count;
+}
+
+// src/lib/mcp-config.ts
+import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function generateMcpConfig(apiUrl, apiToken, boardId) {
+  const localMcpPath = join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const useLocal = existsSync(localMcpPath);
+  const kantbanServer = useLocal ? {
+    command: "node",
+    args: [localMcpPath],
+    env: {
+      KANTBAN_API_TOKEN: apiToken,
+      KANTBAN_API_URL: apiUrl
+    }
+  } : {
+    command: "npx",
+    args: ["-y", "kantban-mcp@latest"],
+    env: {
+      KANTBAN_API_TOKEN: apiToken,
+      KANTBAN_API_URL: apiUrl
+    }
+  };
+  const config = {
+    mcpServers: {
+      kantban: kantbanServer
+    }
+  };
+  const dir = join(homedir(), ".kantban", "pipelines", boardId);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const filePath = join(dir, "mcp-config.json");
+  writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+  return filePath;
+}
+function cleanupMcpConfig(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      unlinkSync(filePath);
+    }
+  } catch {
+  }
+}
+function generateGateProxyMcpConfig(apiUrl, apiToken, boardId, gateConfigPath, columnId, columnName, projectId) {
+  const localMcpPath = join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const useLocal = existsSync(localMcpPath);
+  const kantbanServer = useLocal ? { command: "node", args: [localMcpPath], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl } } : { command: "npx", args: ["-y", "kantban-mcp@latest"], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl } };
+  const gateProxyPath = join(__dirname, "gate-proxy-server.js");
+  const gateProxyServer = {
+    command: "node",
+    args: [gateProxyPath],
+    env: {
+      GATE_CONFIG_PATH: gateConfigPath,
+      COLUMN_ID: columnId,
+      COLUMN_NAME: columnName,
+      PROJECT_ID: projectId,
+      KANTBAN_API_TOKEN: apiToken,
+      KANTBAN_API_URL: apiUrl
+    }
+  };
+  const config = {
+    mcpServers: {
+      kantban: kantbanServer,
+      "kantban-gates": gateProxyServer
+    }
+  };
+  const dir = join(homedir(), ".kantban", "pipelines", boardId);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const filePath = join(dir, `mcp-config-${columnId}.json`);
+  writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+  return filePath;
+}
+function cleanupGateProxyConfigs(pipelineDir) {
+  try {
+    const files = readdirSync(pipelineDir);
+    for (const f of files) {
+      if (f.startsWith("mcp-config-") && f.endsWith(".json")) {
+        try {
+          unlinkSync(join(pipelineDir, f));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+export {
+  parseJsonFromLlmOutput,
+  composeStuckDetectionPrompt,
+  parseStuckDetectionResponse,
+  classifyTrajectory,
+  LoopCheckpointSchema,
+  VerdictSchema,
+  parseGateConfig,
+  resolveGatesForColumn,
+  parseTimeout,
+  RalphLoop,
+  generateMcpConfig,
+  cleanupMcpConfig,
+  generateGateProxyMcpConfig,
+  cleanupGateProxyConfigs
+};
+//# sourceMappingURL=chunk-ZCUIGFSP.js.map