@locusai/shared 0.16.2 → 0.17.1

package/dist/index.js

@@ -35,38 +35,16 @@ __export(exports_src, {
   isValidTransition: () => isValidTransition,
   isUIIntentType: () => isUIIntentType,
   isTerminalStatus: () => isTerminalStatus,
-  isJwtUser: () => isJwtUser,
   isHostEventType: () => isHostEventType,
-  isApiKeyUser: () => isApiKeyUser,
   getNextStatus: () => getNextStatus,
-  getAuthUserId: () => getAuthUserId,
   generateUUID: () => generateUUID,
   createUIIntent: () => createUIIntent,
   createProtocolError: () => createProtocolError,
   createHostEvent: () => createHostEvent,
   createErrorEvent: () => createErrorEvent,
   createCliStreamEvent: () => createCliStreamEvent,
-  WorkspacesResponseSchema: () => WorkspacesResponseSchema,
-  WorkspaceStatsSchema: () => WorkspaceStatsSchema,
-  WorkspaceStatsResponseSchema: () => WorkspaceStatsResponseSchema,
-  WorkspaceSchema: () => WorkspaceSchema,
-  WorkspaceResponseSchema: () => WorkspaceResponseSchema,
-  WorkspaceIdParamSchema: () => WorkspaceIdParamSchema,
-  WorkspaceCreatedPayloadSchema: () => WorkspaceCreatedPayloadSchema,
   WorkspaceContextSchema: () => WorkspaceContextSchema,
-  WorkspaceAndUserParamSchema: () => WorkspaceAndUserParamSchema,
   WebviewReadyIntentSchema: () => WebviewReadyIntentSchema,
-  VerifyOtpSchema: () => VerifyOtpSchema,
-  UserSchema: () => UserSchema,
-  UserRole: () => UserRole,
-  UpdateWorkspaceSchema: () => UpdateWorkspaceSchema,
-  UpdateUserSchema: () => UpdateUserSchema,
-  UpdateTaskSchema: () => UpdateTaskSchema,
-  UpdateSprintSchema: () => UpdateSprintSchema,
-  UpdateOrganizationSchema: () => UpdateOrganizationSchema,
-  UpdateDocSchema: () => UpdateDocSchema,
-  UpdateDocGroupSchema: () => UpdateDocGroupSchema,
-  UnlockSchema: () => UnlockSchema,
   UIIntentTypeSchema: () => UIIntentTypeSchema,
   UIIntentType: () => UIIntentType,
   UIIntentSchema: () => UIIntentSchema,
@@ -77,29 +55,10 @@ __export(exports_src, {
   TimelineEntryKind: () => TimelineEntryKind,
   ThinkingEventSchema: () => ThinkingEventSchema,
   TextDeltaEventSchema: () => TextDeltaEventSchema,
-  TasksResponseSchema: () => TasksResponseSchema,
-  TaskStatus: () => TaskStatus,
-  TaskSchema: () => TaskSchema,
-  TaskResponseSchema: () => TaskResponseSchema,
-  TaskQuerySchema: () => TaskQuerySchema,
-  TaskPriority: () => TaskPriority,
-  TaskIdParamSchema: () => TaskIdParamSchema,
-  TaskIdOnlyParamSchema: () => TaskIdOnlyParamSchema,
-  TaskDeletedPayloadSchema: () => TaskDeletedPayloadSchema,
-  TaskCreatedPayloadSchema: () => TaskCreatedPayloadSchema,
   TERMINAL_STATUSES: () => TERMINAL_STATUSES,
   SuccessResponseSchema: () => SuccessResponseSchema,
   SubmitPromptIntentSchema: () => SubmitPromptIntentSchema,
   StopSessionIntentSchema: () => StopSessionIntentSchema,
-  StatusChangedPayloadSchema: () => StatusChangedPayloadSchema,
-  SprintsResponseSchema: () => SprintsResponseSchema,
-  SprintStatusChangedPayloadSchema: () => SprintStatusChangedPayloadSchema,
-  SprintStatus: () => SprintStatus,
-  SprintSchema: () => SprintSchema,
-  SprintResponseSchema: () => SprintResponseSchema,
-  SprintQuerySchema: () => SprintQuerySchema,
-  SprintIdParamSchema: () => SprintIdParamSchema,
-  SprintCreatedPayloadSchema: () => SprintCreatedPayloadSchema,
   SessionTransitionEventSchema: () => SessionTransitionEventSchema,
   SessionTransitionEvent: () => SessionTransitionEvent,
   SessionSummarySchema: () => SessionSummarySchema,
@@ -110,80 +69,22 @@ __export(exports_src, {
   SessionListEventSchema: () => SessionListEventSchema,
   SessionCompletedEventSchema: () => SessionCompletedEventSchema,
   SelectionContextSchema: () => SelectionContextSchema,
-  STALE_AGENT_TIMEOUT_MS: () => STALE_AGENT_TIMEOUT_MS,
   SESSION_TRANSITIONS: () => SESSION_TRANSITIONS,
   ResumeSessionIntentSchema: () => ResumeSessionIntentSchema,
   RequestSessionsIntentSchema: () => RequestSessionsIntentSchema,
   RequestSessionDetailIntentSchema: () => RequestSessionDetailIntentSchema,
-  ReportCiResultSchema: () => ReportCiResultSchema,
-  RecordCiSchema: () => RecordCiSchema,
   ProtocolVersionSchema: () => ProtocolVersionSchema,
   ProtocolErrorSchema: () => ProtocolErrorSchema,
   ProtocolErrorCodeSchema: () => ProtocolErrorCodeSchema,
   ProtocolErrorCode: () => ProtocolErrorCode,
   ProtocolEnvelopeSchema: () => ProtocolEnvelopeSchema,
-  PaginationRequestSchema: () => PaginationRequestSchema,
-  PaginationMetaSchema: () => PaginationMetaSchema,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  OtpRequestSchema: () => OtpRequestSchema,
-  OrganizationsResponseSchema: () => OrganizationsResponseSchema,
-  OrganizationSchema: () => OrganizationSchema,
-  OrganizationResponseSchema: () => OrganizationResponseSchema,
-  OrgIdParamSchema: () => OrgIdParamSchema,
-  MembershipWithUserSchema: () => MembershipWithUserSchema,
-  MembershipRole: () => MembershipRole,
-  MembershipResponseSchema: () => MembershipResponseSchema,
-  MembershipIdParamSchema: () => MembershipIdParamSchema,
-  MembersResponseSchema: () => MembersResponseSchema,
-  MemberInvitedPayloadSchema: () => MemberInvitedPayloadSchema,
-  MemberAddedPayloadSchema: () => MemberAddedPayloadSchema,
-  LockSchema: () => LockSchema,
-  JwtAuthUserSchema: () => JwtAuthUserSchema,
-  JWTPayloadSchema: () => JWTPayloadSchema,
-  InvitationsResponseSchema: () => InvitationsResponseSchema,
-  InvitationVerifyParamSchema: () => InvitationVerifyParamSchema,
-  InvitationSchema: () => InvitationSchema,
-  InvitationResponseSchema: () => InvitationResponseSchema,
-  InvitationQuerySchema: () => InvitationQuerySchema,
-  InvitationIdParamSchema: () => InvitationIdParamSchema,
   HostEventTypeSchema: () => HostEventTypeSchema,
   HostEventType: () => HostEventType,
   HostEventSchema: () => HostEventSchema,
-  EventsResponseSchema: () => EventsResponseSchema,
-  EventType: () => EventType,
-  EventSchema: () => EventSchema,
-  EventResponseSchema: () => EventResponseSchema,
-  EventQuerySchema: () => EventQuerySchema,
-  EventPayloadSchema: () => EventPayloadSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
   ErrorEventSchema: () => ErrorEventSchema,
-  DocsResponseSchema: () => DocsResponseSchema,
-  DocType: () => DocType,
-  DocSchema: () => DocSchema,
-  DocResponseSchema: () => DocResponseSchema,
-  DocQuerySchema: () => DocQuerySchema,
-  DocIdParamSchema: () => DocIdParamSchema,
-  DocGroupsResponseSchema: () => DocGroupsResponseSchema,
-  DocGroupSchemaForDoc: () => DocGroupSchemaForDoc,
-  DocGroupSchema: () => DocGroupSchema,
-  DocGroupResponseSchema: () => DocGroupResponseSchema,
-  DocGroupIdParamSchema: () => DocGroupIdParamSchema,
-  DispatchTaskSchema: () => DispatchTaskSchema,
-  CreateWorkspaceSchema: () => CreateWorkspaceSchema,
-  CreateUserSchema: () => CreateUserSchema,
-  CreateTaskSchema: () => CreateTaskSchema,
-  CreateSprintSchema: () => CreateSprintSchema,
-  CreateOrganizationSchema: () => CreateOrganizationSchema,
-  CreateInvitationSchema: () => CreateInvitationSchema,
-  CreateDocSchema: () => CreateDocSchema,
-  CreateDocGroupSchema: () => CreateDocGroupSchema,
-  CreateArtifactSchema: () => CreateArtifactSchema,
-  CreateApiKeySchema: () => CreateApiKeySchema,
   ContextPayloadSchema: () => ContextPayloadSchema,
-  CompleteRegistrationSchema: () => CompleteRegistrationSchema,
-  CommentSchema: () => CommentSchema,
-  CommentResponseSchema: () => CommentResponseSchema,
-  CommentAddedPayloadSchema: () => CommentAddedPayloadSchema,
   CliToolStartedEventSchema: () => CliToolStartedEventSchema,
   CliToolCompletedEventSchema: () => CliToolCompletedEventSchema,
   CliThinkingEventSchema: () => CliThinkingEventSchema,
@@ -196,70 +97,12 @@ __export(exports_src, {
   CliErrorEventSchema: () => CliErrorEventSchema,
   CliDoneEventSchema: () => CliDoneEventSchema,
   ClearSessionIntentSchema: () => ClearSessionIntentSchema,
-  CiRanPayloadSchema: () => CiRanPayloadSchema,
-  ChecklistItemSchema: () => ChecklistItemSchema,
-  ChecklistInitializedPayloadSchema: () => ChecklistInitializedPayloadSchema,
-  BaseEntitySchema: () => BaseEntitySchema,
-  AuthenticatedUserSchema: () => AuthenticatedUserSchema,
-  AuthResponseSchema: () => AuthResponseSchema,
-  AuthContextSchema: () => AuthContextSchema,
-  AssigneeRole: () => AssigneeRole,
-  ArtifactsResponseSchema: () => ArtifactsResponseSchema,
-  ArtifactSchema: () => ArtifactSchema,
-  ArtifactResponseSchema: () => ArtifactResponseSchema,
-  ArtifactParamSchema: () => ArtifactParamSchema,
-  ApiResponseSchema: () => ApiResponseSchema,
-  ApiKeyQuerySchema: () => ApiKeyQuerySchema,
-  ApiKeyIdParamSchema: () => ApiKeyIdParamSchema,
-  ApiKeyAuthUserSchema: () => ApiKeyAuthUserSchema,
-  AgentsListResponse: () => AgentsListResponse,
-  AgentRegistrationResponse: () => AgentRegistrationResponse,
-  AgentHeartbeatSchema: () => AgentHeartbeatSchema,
-  AddWorkspaceMemberSchema: () => AddWorkspaceMemberSchema,
-  AddMemberSchema: () => AddMemberSchema,
-  AddCommentSchema: () => AddCommentSchema,
-  ActivityResponseSchema: () => ActivityResponseSchema,
-  ActiveFileContextSchema: () => ActiveFileContextSchema,
-  AcceptanceItemSchema: () => AcceptanceItemSchema,
-  AcceptInvitationSchema: () => AcceptInvitationSchema,
-  AcceptInvitationResponseSchema: () => AcceptInvitationResponseSchema,
-  APIKeySchema: () => APIKeySchema,
-  APIKeyCreateResponseSchema: () => APIKeyCreateResponseSchema
+  ActiveFileContextSchema: () => ActiveFileContextSchema
 });
 module.exports = __toCommonJS(exports_src);
 
 // src/common.ts
 var import_zod = require("zod");
-var BaseEntitySchema = import_zod.z.object({
-  id: import_zod.z.uuid(),
-  createdAt: import_zod.z.union([import_zod.z.date(), import_zod.z.number()]),
-  updatedAt: import_zod.z.union([import_zod.z.date(), import_zod.z.number()])
-});
-var PaginationMetaSchema = import_zod.z.object({
-  page: import_zod.z.number(),
-  limit: import_zod.z.number(),
-  total: import_zod.z.number(),
-  totalPages: import_zod.z.number()
-});
-var PaginationRequestSchema = import_zod.z.object({
-  page: import_zod.z.coerce.number().int().min(1).default(1),
-  limit: import_zod.z.coerce.number().int().min(1).max(100).default(20)
-});
-var ApiResponseSchema = import_zod.z.object({
-  success: import_zod.z.boolean(),
-  data: import_zod.z.unknown().optional(),
-  error: import_zod.z.object({
-    code: import_zod.z.string(),
-    message: import_zod.z.string(),
-    details: import_zod.z.unknown().optional()
-  }).optional(),
-  meta: import_zod.z.object({
-    pagination: PaginationMetaSchema.optional(),
-    timestamp: import_zod.z.string(),
-    path: import_zod.z.string(),
-    requestId: import_zod.z.string().optional()
-  }).optional()
-});
 var SuccessResponseSchema = import_zod.z.object({
   success: import_zod.z.literal(true),
   message: import_zod.z.string().optional()
@@ -279,739 +122,20 @@ function generateUUID() {
     return v.toString(16);
   });
 }
-// src/constants.ts
-var STALE_AGENT_TIMEOUT_MS = 10 * 60 * 1000;
-// src/enums.ts
-var UserRole;
-((UserRole2) => {
-  UserRole2["USER"] = "USER";
-  UserRole2["ADMIN"] = "ADMIN";
-})(UserRole ||= {});
-var MembershipRole;
-((MembershipRole2) => {
-  MembershipRole2["OWNER"] = "OWNER";
-  MembershipRole2["ADMIN"] = "ADMIN";
-  MembershipRole2["MEMBER"] = "MEMBER";
-  MembershipRole2["VIEWER"] = "VIEWER";
-})(MembershipRole ||= {});
-var TaskStatus;
-((TaskStatus2) => {
-  TaskStatus2["BACKLOG"] = "BACKLOG";
-  TaskStatus2["IN_PROGRESS"] = "IN_PROGRESS";
-  TaskStatus2["IN_REVIEW"] = "IN_REVIEW";
-  TaskStatus2["BLOCKED"] = "BLOCKED";
-  TaskStatus2["DONE"] = "DONE";
-})(TaskStatus ||= {});
-var TaskPriority;
-((TaskPriority2) => {
-  TaskPriority2["LOW"] = "LOW";
-  TaskPriority2["MEDIUM"] = "MEDIUM";
-  TaskPriority2["HIGH"] = "HIGH";
-  TaskPriority2["CRITICAL"] = "CRITICAL";
-})(TaskPriority ||= {});
-var AssigneeRole;
-((AssigneeRole2) => {
-  AssigneeRole2["BACKEND"] = "BACKEND";
-  AssigneeRole2["FRONTEND"] = "FRONTEND";
-  AssigneeRole2["QA"] = "QA";
-  AssigneeRole2["PM"] = "PM";
-  AssigneeRole2["DESIGN"] = "DESIGN";
-})(AssigneeRole ||= {});
-var SprintStatus;
-((SprintStatus2) => {
-  SprintStatus2["PLANNED"] = "PLANNED";
-  SprintStatus2["ACTIVE"] = "ACTIVE";
-  SprintStatus2["COMPLETED"] = "COMPLETED";
-})(SprintStatus ||= {});
-var EventType;
-((EventType2) => {
-  EventType2["TASK_CREATED"] = "TASK_CREATED";
-  EventType2["TASK_UPDATED"] = "TASK_UPDATED";
-  EventType2["TASK_DELETED"] = "TASK_DELETED";
-  EventType2["STATUS_CHANGED"] = "STATUS_CHANGED";
-  EventType2["COMMENT_ADDED"] = "COMMENT_ADDED";
-  EventType2["CI_RAN"] = "CI_RAN";
-  EventType2["WORKSPACE_CREATED"] = "WORKSPACE_CREATED";
-  EventType2["MEMBER_ADDED"] = "MEMBER_ADDED";
-  EventType2["MEMBER_INVITED"] = "MEMBER_INVITED";
-  EventType2["SPRINT_CREATED"] = "SPRINT_CREATED";
-  EventType2["SPRINT_STATUS_CHANGED"] = "SPRINT_STATUS_CHANGED";
-  EventType2["SPRINT_DELETED"] = "SPRINT_DELETED";
-  EventType2["CHECKLIST_INITIALIZED"] = "CHECKLIST_INITIALIZED";
-  EventType2["AGENT_HEARTBEAT"] = "AGENT_HEARTBEAT";
-  EventType2["TASK_DISPATCHED"] = "TASK_DISPATCHED";
-  EventType2["PR_CREATED"] = "PR_CREATED";
-  EventType2["PR_REVIEWED"] = "PR_REVIEWED";
-  EventType2["PR_MERGED"] = "PR_MERGED";
-})(EventType ||= {});
-// src/models/activity.ts
-var import_zod2 = require("zod");
-var CommentSchema = BaseEntitySchema.extend({
-  taskId: import_zod2.z.uuid(),
-  author: import_zod2.z.string().min(1),
-  text: import_zod2.z.string().min(1)
-});
-var ArtifactSchema = BaseEntitySchema.extend({
-  taskId: import_zod2.z.uuid(),
-  type: import_zod2.z.string().min(1),
-  title: import_zod2.z.string().min(1),
-  contentText: import_zod2.z.string().optional(),
-  filePath: import_zod2.z.string().optional(),
-  url: import_zod2.z.string().optional(),
-  size: import_zod2.z.string().optional(),
-  createdBy: import_zod2.z.string().min(1)
-});
-var TaskCreatedPayloadSchema = import_zod2.z.object({
-  title: import_zod2.z.string()
-});
-var TaskDeletedPayloadSchema = import_zod2.z.object({
-  title: import_zod2.z.string()
-});
-var StatusChangedPayloadSchema = import_zod2.z.object({
-  title: import_zod2.z.string(),
-  oldStatus: import_zod2.z.enum(TaskStatus),
-  newStatus: import_zod2.z.enum(TaskStatus)
-});
-var CommentAddedPayloadSchema = import_zod2.z.object({
-  title: import_zod2.z.string(),
-  author: import_zod2.z.string(),
-  text: import_zod2.z.string()
-});
-var WorkspaceCreatedPayloadSchema = import_zod2.z.object({
-  name: import_zod2.z.string()
-});
-var MemberAddedPayloadSchema = import_zod2.z.object({
-  userId: import_zod2.z.string(),
-  role: import_zod2.z.string()
-});
-var MemberInvitedPayloadSchema = import_zod2.z.object({
-  email: import_zod2.z.string()
-});
-var SprintCreatedPayloadSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  sprintId: import_zod2.z.uuid()
-});
-var SprintStatusChangedPayloadSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  sprintId: import_zod2.z.uuid(),
-  oldStatus: import_zod2.z.enum(SprintStatus),
-  newStatus: import_zod2.z.enum(SprintStatus)
-});
-var ChecklistInitializedPayloadSchema = import_zod2.z.object({
-  itemCount: import_zod2.z.number()
-});
-var CiRanPayloadSchema = import_zod2.z.object({
-  preset: import_zod2.z.string(),
-  ok: import_zod2.z.boolean(),
-  summary: import_zod2.z.string(),
-  source: import_zod2.z.string(),
-  deferred: import_zod2.z.boolean(),
-  processed: import_zod2.z.boolean(),
-  commands: import_zod2.z.array(import_zod2.z.object({ cmd: import_zod2.z.string(), exitCode: import_zod2.z.number() }))
-});
-var EventPayloadSchema = import_zod2.z.discriminatedUnion("type", [
-  import_zod2.z.object({
-    type: import_zod2.z.literal("TASK_CREATED" /* TASK_CREATED */),
-    payload: TaskCreatedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("TASK_DELETED" /* TASK_DELETED */),
-    payload: TaskDeletedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("STATUS_CHANGED" /* STATUS_CHANGED */),
-    payload: StatusChangedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("COMMENT_ADDED" /* COMMENT_ADDED */),
-    payload: CommentAddedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("WORKSPACE_CREATED" /* WORKSPACE_CREATED */),
-    payload: WorkspaceCreatedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("MEMBER_ADDED" /* MEMBER_ADDED */),
-    payload: MemberAddedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("MEMBER_INVITED" /* MEMBER_INVITED */),
-    payload: MemberInvitedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("SPRINT_CREATED" /* SPRINT_CREATED */),
-    payload: SprintCreatedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("SPRINT_STATUS_CHANGED" /* SPRINT_STATUS_CHANGED */),
-    payload: SprintStatusChangedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("CHECKLIST_INITIALIZED" /* CHECKLIST_INITIALIZED */),
-    payload: ChecklistInitializedPayloadSchema
-  }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("CI_RAN" /* CI_RAN */),
-    payload: CiRanPayloadSchema
-  })
-]);
-var EventSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  workspaceId: import_zod2.z.string(),
-  taskId: import_zod2.z.uuid().optional().nullable(),
-  userId: import_zod2.z.string().optional().nullable(),
-  type: import_zod2.z.enum(EventType),
-  payload: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
-  createdAt: import_zod2.z.union([import_zod2.z.date(), import_zod2.z.number()])
-});
-var ArtifactParamSchema = import_zod2.z.object({
-  taskId: import_zod2.z.string().uuid("Invalid Task ID"),
-  type: import_zod2.z.string().min(1, "Artifact type required"),
-  filename: import_zod2.z.string().min(1, "Filename required")
-});
-var TaskIdOnlyParamSchema = import_zod2.z.object({
-  taskId: import_zod2.z.string().uuid("Invalid Task ID")
-});
-var EventQuerySchema = import_zod2.z.object({
-  taskId: import_zod2.z.string().uuid("Invalid Task ID").optional()
-});
-var EventResponseSchema = import_zod2.z.object({
-  event: EventSchema
-});
-var EventsResponseSchema = import_zod2.z.object({
-  events: import_zod2.z.array(EventSchema)
-});
-var ActivityResponseSchema = import_zod2.z.object({
-  activity: import_zod2.z.array(EventSchema)
-});
-var CommentResponseSchema = import_zod2.z.object({
-  comment: CommentSchema
-});
-var ArtifactResponseSchema = import_zod2.z.object({
-  artifact: ArtifactSchema
-});
-var ArtifactsResponseSchema = import_zod2.z.object({
-  artifacts: import_zod2.z.array(ArtifactSchema)
-});
-var CreateArtifactSchema = import_zod2.z.object({
-  taskId: import_zod2.z.uuid(),
-  type: import_zod2.z.string().min(1),
-  title: import_zod2.z.string().min(1),
-  contentText: import_zod2.z.string().optional()
-});
-var ReportCiResultSchema = import_zod2.z.object({
-  workspaceId: import_zod2.z.uuid(),
-  taskId: import_zod2.z.uuid().optional(),
-  preset: import_zod2.z.string(),
-  ok: import_zod2.z.boolean(),
-  summary: import_zod2.z.string(),
-  commands: import_zod2.z.array(import_zod2.z.object({
-    cmd: import_zod2.z.string(),
-    exitCode: import_zod2.z.number()
-  }))
-});
-// src/models/agent.ts
-var import_zod3 = require("zod");
-var LockSchema = import_zod3.z.object({
-  agentId: import_zod3.z.string().min(1),
-  ttlSeconds: import_zod3.z.number().positive()
-});
-var UnlockSchema = import_zod3.z.object({
-  agentId: import_zod3.z.string().min(1)
-});
-var AgentHeartbeatSchema = import_zod3.z.object({
-  agentId: import_zod3.z.string().min(1),
-  currentTaskId: import_zod3.z.string().uuid().nullable().optional(),
-  status: import_zod3.z.enum(["IDLE", "WORKING", "COMPLETED", "FAILED"]).optional().default("WORKING")
-});
-var AgentRegistrationResponse = import_zod3.z.object({
-  agentId: import_zod3.z.string(),
-  workspaceId: import_zod3.z.string(),
-  currentTaskId: import_zod3.z.string().nullable(),
-  status: import_zod3.z.string(),
-  lastHeartbeat: import_zod3.z.string(),
-  createdAt: import_zod3.z.string()
-});
-var AgentsListResponse = import_zod3.z.object({
-  agents: import_zod3.z.array(AgentRegistrationResponse)
-});
-// src/models/auth.ts
-var import_zod5 = require("zod");
-
-// src/models/user.ts
-var import_zod4 = require("zod");
-var UserSchema = BaseEntitySchema.extend({
-  email: import_zod4.z.string().email(),
-  name: import_zod4.z.string().min(1),
-  avatarUrl: import_zod4.z.string().url().nullable().optional(),
-  role: import_zod4.z.enum(UserRole),
-  orgId: import_zod4.z.uuid().optional().nullable(),
-  workspaceId: import_zod4.z.uuid().optional().nullable(),
-  companyName: import_zod4.z.string().optional(),
-  userRole: import_zod4.z.string().optional(),
-  teamSize: import_zod4.z.string().optional(),
-  onboardingCompleted: import_zod4.z.boolean().default(false),
-  emailVerified: import_zod4.z.boolean().default(false)
-});
-var CreateUserSchema = import_zod4.z.object({
-  email: import_zod4.z.string().email(),
-  name: import_zod4.z.string().min(1)
-});
-var UpdateUserSchema = UserSchema.partial().omit({
-  id: true,
-  email: true,
-  createdAt: true,
-  updatedAt: true
-});
-
-// src/models/auth.ts
-var JwtAuthUserSchema = import_zod5.z.object({
-  authType: import_zod5.z.literal("jwt"),
-  id: import_zod5.z.uuid(),
-  email: import_zod5.z.string().email(),
-  name: import_zod5.z.string(),
-  role: import_zod5.z.enum(UserRole),
-  orgId: import_zod5.z.uuid().nullable().optional(),
-  workspaceId: import_zod5.z.uuid().nullable().optional()
-});
-var ApiKeyAuthUserSchema = import_zod5.z.object({
-  authType: import_zod5.z.literal("api_key"),
-  apiKeyId: import_zod5.z.string(),
-  apiKeyName: import_zod5.z.string(),
-  orgId: import_zod5.z.string().optional(),
-  workspaceId: import_zod5.z.string().optional()
-});
-var AuthenticatedUserSchema = import_zod5.z.discriminatedUnion("authType", [
-  JwtAuthUserSchema,
-  ApiKeyAuthUserSchema
-]);
-function isJwtUser(user) {
-  return user.authType === "jwt";
-}
-function isApiKeyUser(user) {
-  return user.authType === "api_key";
-}
-function getAuthUserId(user) {
-  return isJwtUser(user) ? user.id : null;
-}
-var AuthResponseSchema = import_zod5.z.object({
-  token: import_zod5.z.string(),
-  user: UserSchema
-});
-var OtpRequestSchema = import_zod5.z.object({
-  email: import_zod5.z.string().email("Invalid email address")
-});
-var VerifyOtpSchema = import_zod5.z.object({
-  email: import_zod5.z.string().email("Invalid email address"),
-  otp: import_zod5.z.string().length(6, "Verification code must be 6 digits")
-});
-var CompleteRegistrationSchema = import_zod5.z.object({
-  email: import_zod5.z.string().email("Invalid email address"),
-  otp: import_zod5.z.string().length(6, "Verification code must be 6 digits"),
-  name: import_zod5.z.string().min(1, "Name is required").max(100),
-  companyName: import_zod5.z.string().max(100).optional(),
-  teamSize: import_zod5.z.enum(["solo", "2-10", "11-50", "51-200", "200+"]).optional(),
-  userRole: import_zod5.z.enum(["developer", "designer", "product_manager", "other"]).optional(),
-  workspaceName: import_zod5.z.string().max(100).optional(),
-  invitedEmails: import_zod5.z.array(import_zod5.z.string().email()).optional()
-});
-var JWTPayloadSchema = import_zod5.z.object({
-  sub: import_zod5.z.string(),
-  email: import_zod5.z.string().email(),
-  name: import_zod5.z.string(),
-  role: import_zod5.z.string(),
-  orgId: import_zod5.z.uuid().optional(),
-  iat: import_zod5.z.number(),
-  exp: import_zod5.z.number()
-});
-var AuthContextSchema = import_zod5.z.object({
-  userId: import_zod5.z.string(),
-  email: import_zod5.z.string().email(),
-  name: import_zod5.z.string(),
-  role: import_zod5.z.string(),
-  orgId: import_zod5.z.uuid().optional(),
-  workspaceId: import_zod5.z.uuid().optional(),
-  authType: import_zod5.z.enum(["jwt", "api_key", "local"])
-});
-var APIKeySchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  name: import_zod5.z.string(),
-  keyPrefix: import_zod5.z.string(),
-  workspaceId: import_zod5.z.string(),
-  lastUsedAt: import_zod5.z.number().nullable(),
-  createdAt: import_zod5.z.number()
-});
-var APIKeyCreateResponseSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  name: import_zod5.z.string(),
-  keyPrefix: import_zod5.z.string(),
-  key: import_zod5.z.string(),
-  createdAt: import_zod5.z.number()
-});
-var ApiKeyIdParamSchema = import_zod5.z.object({
-  id: import_zod5.z.string().uuid("Invalid API Key ID")
-});
-var ApiKeyQuerySchema = import_zod5.z.object({
-  workspaceId: import_zod5.z.string().uuid("Invalid Workspace ID").optional()
-});
-var CreateApiKeySchema = import_zod5.z.object({
-  workspaceId: import_zod5.z.string().uuid("Invalid Workspace ID").optional(),
-  name: import_zod5.z.string().min(1, "Name is required").max(100),
-  expiresInDays: import_zod5.z.number().int().positive().optional()
-});
-// src/models/ci.ts
-var import_zod6 = require("zod");
-var RecordCiSchema = import_zod6.z.object({
-  taskId: import_zod6.z.uuid(),
-  workspaceId: import_zod6.z.uuid(),
-  result: import_zod6.z.object({
-    ok: import_zod6.z.boolean(),
-    summary: import_zod6.z.string(),
-    commands: import_zod6.z.array(import_zod6.z.object({
-      cmd: import_zod6.z.string(),
-      exitCode: import_zod6.z.number(),
-      durationMs: import_zod6.z.number().optional(),
-      error: import_zod6.z.string().optional()
-    })),
-    preset: import_zod6.z.string()
-  })
-});
-// src/models/doc.ts
-var import_zod7 = require("zod");
-var DocGroupSchemaForDoc = import_zod7.z.object({
-  id: import_zod7.z.uuid(),
-  name: import_zod7.z.string()
-});
-var DocType;
-((DocType2) => {
-  DocType2["GENERAL"] = "GENERAL";
-  DocType2["PRD"] = "PRD";
-  DocType2["TECH_SPEC"] = "TECH_SPEC";
-  DocType2["ADR"] = "ADR";
-  DocType2["API_DESIGN"] = "API_DESIGN";
-})(DocType ||= {});
-var DocSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod7.z.uuid(),
-  groupId: import_zod7.z.uuid().nullable().optional(),
-  title: import_zod7.z.string().min(1, "Title is required"),
-  content: import_zod7.z.string().default(""),
-  type: import_zod7.z.enum(DocType).default("GENERAL" /* GENERAL */),
-  group: DocGroupSchemaForDoc.nullable().optional()
-});
-var CreateDocSchema = import_zod7.z.object({
-  title: import_zod7.z.string().min(1, "Title is required"),
-  content: import_zod7.z.string().optional(),
-  type: import_zod7.z.enum(DocType).optional().default("GENERAL" /* GENERAL */),
-  groupId: import_zod7.z.string().optional()
-});
-var UpdateDocSchema = import_zod7.z.object({
-  title: import_zod7.z.string().min(1).optional(),
-  content: import_zod7.z.string().optional(),
-  type: import_zod7.z.enum(DocType).optional(),
-  groupId: import_zod7.z.string().nullable().optional()
-});
-var DocResponseSchema = import_zod7.z.object({
-  doc: DocSchema
-});
-var DocsResponseSchema = import_zod7.z.object({
-  docs: import_zod7.z.array(DocSchema)
-});
-var DocIdParamSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid("Invalid Doc ID")
-});
-var DocQuerySchema = import_zod7.z.object({
-  workspaceId: import_zod7.z.string().uuid("Invalid Workspace ID").optional()
-});
-// src/models/doc-group.ts
-var import_zod8 = require("zod");
-var DocGroupSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod8.z.uuid(),
-  name: import_zod8.z.string().min(1, "Name is required"),
-  order: import_zod8.z.number().default(0)
-});
-var CreateDocGroupSchema = import_zod8.z.object({
-  name: import_zod8.z.string().min(1, "Name is required"),
-  order: import_zod8.z.number().optional()
-});
-var UpdateDocGroupSchema = import_zod8.z.object({
-  name: import_zod8.z.string().min(1).optional(),
-  order: import_zod8.z.number().optional()
-});
-var DocGroupResponseSchema = import_zod8.z.object({
-  group: DocGroupSchema
-});
-var DocGroupsResponseSchema = import_zod8.z.object({
-  groups: import_zod8.z.array(DocGroupSchema)
-});
-var DocGroupIdParamSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid("Invalid Group ID")
-});
-// src/models/invitation.ts
-var import_zod9 = require("zod");
-var InvitationSchema = BaseEntitySchema.extend({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
-  email: import_zod9.z.string().email("Invalid email address"),
-  role: import_zod9.z.enum(MembershipRole),
-  token: import_zod9.z.string(),
-  expiresAt: import_zod9.z.number(),
-  acceptedAt: import_zod9.z.number().nullable().optional(),
-  invitedBy: import_zod9.z.uuid()
-});
-var CreateInvitationSchema = import_zod9.z.object({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
-  email: import_zod9.z.string().email("Invalid email address"),
-  role: import_zod9.z.enum(MembershipRole).default("MEMBER" /* MEMBER */)
-});
-var AcceptInvitationSchema = import_zod9.z.object({
-  token: import_zod9.z.string().min(1, "Invitation token is required"),
-  name: import_zod9.z.string().min(1, "Name is required").optional()
-});
-var InvitationIdParamSchema = import_zod9.z.object({
-  id: import_zod9.z.string().uuid("Invalid Invitation ID")
-});
-var InvitationVerifyParamSchema = import_zod9.z.object({
-  token: import_zod9.z.string().min(1, "Token required")
-});
-var InvitationQuerySchema = import_zod9.z.object({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID").optional()
-});
-var InvitationResponseSchema = import_zod9.z.object({
-  invitation: InvitationSchema,
-  userExists: import_zod9.z.boolean().optional()
-});
-var InvitationsResponseSchema = import_zod9.z.object({
-  invitations: import_zod9.z.array(InvitationSchema)
-});
-var AcceptInvitationResponseSchema = import_zod9.z.object({
-  membership: import_zod9.z.object({
-    id: import_zod9.z.uuid(),
-    userId: import_zod9.z.uuid(),
-    orgId: import_zod9.z.uuid(),
-    role: import_zod9.z.enum(MembershipRole),
-    createdAt: import_zod9.z.number()
-  })
-});
-// src/models/organization.ts
-var import_zod10 = require("zod");
-var OrganizationSchema = BaseEntitySchema.extend({
-  name: import_zod10.z.string().min(1, "Name is required").max(100),
-  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").nullable().optional().or(import_zod10.z.literal(""))
-});
-var CreateOrganizationSchema = import_zod10.z.object({
-  name: import_zod10.z.string().min(1, "Name is required").max(100),
-  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").optional().or(import_zod10.z.literal(""))
-});
-var UpdateOrganizationSchema = OrganizationSchema.partial().omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true
-});
-var AddMemberSchema = import_zod10.z.object({
-  userId: import_zod10.z.string().uuid("Invalid User ID"),
-  role: import_zod10.z.enum(["ADMIN", "MEMBER"]).default("MEMBER")
-});
-var MembershipWithUserSchema = import_zod10.z.object({
-  id: import_zod10.z.uuid(),
-  userId: import_zod10.z.uuid(),
-  orgId: import_zod10.z.uuid(),
-  role: import_zod10.z.string(),
-  createdAt: import_zod10.z.number(),
-  user: import_zod10.z.object({
-    id: import_zod10.z.uuid(),
-    email: import_zod10.z.string().email(),
-    name: import_zod10.z.string(),
-    avatarUrl: import_zod10.z.string().url().nullable().optional()
-  })
-});
-var OrgIdParamSchema = import_zod10.z.object({
-  orgId: import_zod10.z.string().uuid("Invalid Organization ID")
-});
-var MembershipIdParamSchema = import_zod10.z.object({
-  id: import_zod10.z.string().uuid("Invalid Membership ID")
-});
-var OrganizationResponseSchema = import_zod10.z.object({
-  organization: OrganizationSchema
-});
-var OrganizationsResponseSchema = import_zod10.z.object({
-  organizations: import_zod10.z.array(OrganizationSchema)
-});
-var MembersResponseSchema = import_zod10.z.object({
-  members: import_zod10.z.array(MembershipWithUserSchema)
-});
-var MembershipResponseSchema = import_zod10.z.object({
-  membership: MembershipWithUserSchema
-});
-// src/models/sprint.ts
-var import_zod11 = require("zod");
-var SprintSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod11.z.uuid().nullable().optional(),
-  name: import_zod11.z.string().min(1, "Name is required").max(100),
-  status: import_zod11.z.enum(SprintStatus),
-  startDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional(),
-  endDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional()
-});
-var CreateSprintSchema = import_zod11.z.object({
-  name: import_zod11.z.string().min(1, "Name is required").max(100),
-  startDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional(),
-  endDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional(),
-  taskIds: import_zod11.z.array(import_zod11.z.string()).optional()
-});
-var UpdateSprintSchema = SprintSchema.partial().omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-  startDate: true,
-  endDate: true
-}).extend({
-  name: import_zod11.z.string().min(1).max(100).optional(),
-  startDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional().nullable(),
-  endDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional().nullable()
-});
-var SprintIdParamSchema = import_zod11.z.object({
-  id: import_zod11.z.string().uuid("Invalid Sprint ID")
-});
-var SprintQuerySchema = import_zod11.z.object({});
-var SprintResponseSchema = import_zod11.z.object({
-  sprint: SprintSchema
-});
-var SprintsResponseSchema = import_zod11.z.object({
-  sprints: import_zod11.z.array(SprintSchema)
-});
-// src/models/task.ts
-var import_zod12 = require("zod");
-var AcceptanceItemSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  text: import_zod12.z.string(),
-  done: import_zod12.z.boolean()
-});
-var TaskSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod12.z.uuid().nullable().optional(),
-  title: import_zod12.z.string().min(1, "Title is required").max(200),
-  description: import_zod12.z.string(),
-  status: import_zod12.z.enum(TaskStatus),
-  priority: import_zod12.z.enum(TaskPriority),
-  labels: import_zod12.z.array(import_zod12.z.string()),
-  assigneeRole: import_zod12.z.enum(AssigneeRole).nullable().optional(),
-  assignedTo: import_zod12.z.string().nullable().optional(),
-  sprintId: import_zod12.z.uuid().nullable().optional(),
-  parentId: import_zod12.z.uuid().nullable().optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).nullable().optional(),
-  prUrl: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema),
-  comments: import_zod12.z.array(CommentSchema).optional(),
-  activityLog: import_zod12.z.array(EventSchema).optional(),
-  docs: import_zod12.z.array(DocSchema),
-  order: import_zod12.z.number().optional()
-});
-var CreateTaskSchema = import_zod12.z.object({
-  title: import_zod12.z.string().min(1, "Title is required").max(200),
-  description: import_zod12.z.string().optional().default(""),
-  status: import_zod12.z.enum(TaskStatus).optional().default("BACKLOG" /* BACKLOG */),
-  priority: import_zod12.z.enum(TaskPriority).optional().default("MEDIUM" /* MEDIUM */),
-  labels: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
-  assigneeRole: import_zod12.z.enum(AssigneeRole).optional(),
-  assignedTo: import_zod12.z.string().nullable().optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).nullable().optional(),
-  parentId: import_zod12.z.string().nullable().optional(),
-  sprintId: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
-  docIds: import_zod12.z.array(import_zod12.z.string()).optional(),
-  order: import_zod12.z.number().optional()
-});
-var UpdateTaskSchema = TaskSchema.partial().omit({
-  id: true,
-  workspaceId: true,
-  createdAt: true,
-  updatedAt: true,
-  dueDate: true,
-  comments: true,
-  activityLog: true,
-  docs: true
-}).extend({
-  title: import_zod12.z.string().min(1).max(200).optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().nullable(),
-  prUrl: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
-  docIds: import_zod12.z.array(import_zod12.z.string()).optional()
-});
-var AddCommentSchema = import_zod12.z.object({
-  author: import_zod12.z.string().min(1, "Author is required"),
-  text: import_zod12.z.string().min(1, "Comment text is required")
-});
-var DispatchTaskSchema = import_zod12.z.object({
-  workerId: import_zod12.z.string().optional(),
-  sprintId: import_zod12.z.uuid().optional().nullable()
-});
-var TaskIdParamSchema = import_zod12.z.object({
-  id: import_zod12.z.string().uuid("Invalid Task ID")
-});
-var TaskQuerySchema = import_zod12.z.object({});
-var TaskResponseSchema = import_zod12.z.object({
-  task: TaskSchema
-});
-var TasksResponseSchema = import_zod12.z.object({
-  tasks: import_zod12.z.array(TaskSchema)
-});
-// src/models/workspace.ts
-var import_zod13 = require("zod");
-var ChecklistItemSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  text: import_zod13.z.string(),
-  done: import_zod13.z.boolean()
-});
-var WorkspaceSchema = BaseEntitySchema.extend({
-  orgId: import_zod13.z.uuid(),
-  name: import_zod13.z.string().min(1, "Name is required").max(100),
-  defaultChecklist: import_zod13.z.array(ChecklistItemSchema).nullable().optional()
-});
-var CreateWorkspaceSchema = import_zod13.z.object({
-  name: import_zod13.z.string().min(1, "Name is required").max(100)
-});
-var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
-  id: true,
-  orgId: true,
-  createdAt: true,
-  updatedAt: true
-});
-var AddWorkspaceMemberSchema = import_zod13.z.object({
-  userId: import_zod13.z.string().uuid("Invalid User ID"),
-  role: import_zod13.z.string().optional()
-});
-var WorkspaceIdParamSchema = import_zod13.z.object({
-  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID")
-});
-var WorkspaceAndUserParamSchema = import_zod13.z.object({
-  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID"),
-  userId: import_zod13.z.string().uuid("Invalid User ID")
-});
-var WorkspaceResponseSchema = import_zod13.z.object({
-  workspace: WorkspaceSchema
-});
-var WorkspacesResponseSchema = import_zod13.z.object({
-  workspaces: import_zod13.z.array(WorkspaceSchema)
-});
-var WorkspaceStatsSchema = import_zod13.z.object({
-  workspaceName: import_zod13.z.string(),
-  taskCounts: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.number()),
-  memberCount: import_zod13.z.number()
-});
-var WorkspaceStatsResponseSchema = import_zod13.z.object({
-  stats: WorkspaceStatsSchema
-});
 // src/protocol/cli-stream.ts
-var import_zod16 = require("zod");
+var import_zod4 = require("zod");
 
 // src/protocol/envelope.ts
-var import_zod14 = require("zod");
+var import_zod2 = require("zod");
 var PROTOCOL_VERSION = 1;
-var ProtocolVersionSchema = import_zod14.z.literal(PROTOCOL_VERSION);
-var ProtocolEnvelopeSchema = import_zod14.z.object({
+var ProtocolVersionSchema = import_zod2.z.literal(PROTOCOL_VERSION);
+var ProtocolEnvelopeSchema = import_zod2.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod14.z.string()
+  type: import_zod2.z.string()
 });
 
 // src/protocol/errors.ts
-var import_zod15 = require("zod");
+var import_zod3 = require("zod");
 var ProtocolErrorCode = {
   CLI_NOT_FOUND: "CLI_NOT_FOUND",
   AUTH_EXPIRED: "AUTH_EXPIRED",
@@ -1022,12 +146,12 @@ var ProtocolErrorCode = {
   SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
   UNKNOWN: "UNKNOWN"
 };
-var ProtocolErrorCodeSchema = import_zod15.z.enum(ProtocolErrorCode);
-var ProtocolErrorSchema = import_zod15.z.object({
+var ProtocolErrorCodeSchema = import_zod3.z.enum(ProtocolErrorCode);
+var ProtocolErrorSchema = import_zod3.z.object({
   code: ProtocolErrorCodeSchema,
-  message: import_zod15.z.string(),
-  details: import_zod15.z.unknown().optional(),
-  recoverable: import_zod15.z.boolean()
+  message: import_zod3.z.string(),
+  details: import_zod3.z.unknown().optional(),
+  recoverable: import_zod3.z.boolean()
 });
 
 // src/protocol/cli-stream.ts
@@ -1041,75 +165,75 @@ var CliStreamEventType = {
   ERROR: "error",
   DONE: "done"
 };
-var CliStreamEventTypeSchema = import_zod16.z.enum(CliStreamEventType);
-var CliStreamBaseSchema = import_zod16.z.object({
+var CliStreamEventTypeSchema = import_zod4.z.enum(CliStreamEventType);
+var CliStreamBaseSchema = import_zod4.z.object({
   protocol: ProtocolVersionSchema,
-  sessionId: import_zod16.z.string(),
-  timestamp: import_zod16.z.number()
+  sessionId: import_zod4.z.string(),
+  timestamp: import_zod4.z.number()
 });
 var CliStartEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.START),
-  payload: import_zod16.z.object({
-    command: import_zod16.z.string(),
-    model: import_zod16.z.string().optional(),
-    provider: import_zod16.z.string().optional(),
-    cwd: import_zod16.z.string().optional()
+  type: import_zod4.z.literal(CliStreamEventType.START),
+  payload: import_zod4.z.object({
+    command: import_zod4.z.string(),
+    model: import_zod4.z.string().optional(),
+    provider: import_zod4.z.string().optional(),
+    cwd: import_zod4.z.string().optional()
   })
 });
 var CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TEXT_DELTA),
-  payload: import_zod16.z.object({
-    content: import_zod16.z.string()
+  type: import_zod4.z.literal(CliStreamEventType.TEXT_DELTA),
+  payload: import_zod4.z.object({
+    content: import_zod4.z.string()
   })
 });
 var CliThinkingEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.THINKING),
-  payload: import_zod16.z.object({
-    content: import_zod16.z.string().optional()
+  type: import_zod4.z.literal(CliStreamEventType.THINKING),
+  payload: import_zod4.z.object({
+    content: import_zod4.z.string().optional()
   })
 });
 var CliToolStartedEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TOOL_STARTED),
-  payload: import_zod16.z.object({
-    tool: import_zod16.z.string(),
-    toolId: import_zod16.z.string().optional(),
-    parameters: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
+  type: import_zod4.z.literal(CliStreamEventType.TOOL_STARTED),
+  payload: import_zod4.z.object({
+    tool: import_zod4.z.string(),
+    toolId: import_zod4.z.string().optional(),
+    parameters: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
   })
 });
 var CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TOOL_COMPLETED),
-  payload: import_zod16.z.object({
-    tool: import_zod16.z.string(),
-    toolId: import_zod16.z.string().optional(),
-    success: import_zod16.z.boolean(),
-    duration: import_zod16.z.number().optional(),
-    error: import_zod16.z.string().optional()
+  type: import_zod4.z.literal(CliStreamEventType.TOOL_COMPLETED),
+  payload: import_zod4.z.object({
+    tool: import_zod4.z.string(),
+    toolId: import_zod4.z.string().optional(),
+    success: import_zod4.z.boolean(),
+    duration: import_zod4.z.number().optional(),
+    error: import_zod4.z.string().optional()
   })
 });
 var CliStatusEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.STATUS),
-  payload: import_zod16.z.object({
-    status: import_zod16.z.string(),
-    message: import_zod16.z.string().optional()
+  type: import_zod4.z.literal(CliStreamEventType.STATUS),
+  payload: import_zod4.z.object({
+    status: import_zod4.z.string(),
+    message: import_zod4.z.string().optional()
   })
 });
 var CliErrorEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.ERROR),
-  payload: import_zod16.z.object({
+  type: import_zod4.z.literal(CliStreamEventType.ERROR),
+  payload: import_zod4.z.object({
     error: ProtocolErrorSchema
   })
 });
 var CliDoneEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.DONE),
-  payload: import_zod16.z.object({
-    exitCode: import_zod16.z.number().int(),
-    duration: import_zod16.z.number(),
-    toolsUsed: import_zod16.z.array(import_zod16.z.string()).optional(),
-    tokensUsed: import_zod16.z.number().optional(),
-    success: import_zod16.z.boolean()
+  type: import_zod4.z.literal(CliStreamEventType.DONE),
+  payload: import_zod4.z.object({
+    exitCode: import_zod4.z.number().int(),
+    duration: import_zod4.z.number(),
+    toolsUsed: import_zod4.z.array(import_zod4.z.string()).optional(),
+    tokensUsed: import_zod4.z.number().optional(),
+    success: import_zod4.z.boolean()
   })
 });
-var CliStreamEventSchema = import_zod16.z.discriminatedUnion("type", [
+var CliStreamEventSchema = import_zod4.z.discriminatedUnion("type", [
   CliStartEventSchema,
   CliTextDeltaEventSchema,
   CliThinkingEventSchema,
@@ -1136,34 +260,34 @@ function parseCliStreamEvent(value) {
   return { success: false, error: result.error };
 }
 // src/protocol/context.ts
-var import_zod17 = require("zod");
-var ActiveFileContextSchema = import_zod17.z.object({
-  filePath: import_zod17.z.string(),
-  languageId: import_zod17.z.string().optional()
-});
-var SelectionContextSchema = import_zod17.z.object({
-  filePath: import_zod17.z.string(),
-  languageId: import_zod17.z.string().optional(),
-  startLine: import_zod17.z.number().int().min(0),
-  startColumn: import_zod17.z.number().int().min(0),
-  endLine: import_zod17.z.number().int().min(0),
-  endColumn: import_zod17.z.number().int().min(0),
-  text: import_zod17.z.string()
-});
-var WorkspaceContextSchema = import_zod17.z.object({
-  rootPath: import_zod17.z.string(),
-  name: import_zod17.z.string().optional()
-});
-var ContextPayloadSchema = import_zod17.z.object({
+var import_zod5 = require("zod");
+var ActiveFileContextSchema = import_zod5.z.object({
+  filePath: import_zod5.z.string(),
+  languageId: import_zod5.z.string().optional()
+});
+var SelectionContextSchema = import_zod5.z.object({
+  filePath: import_zod5.z.string(),
+  languageId: import_zod5.z.string().optional(),
+  startLine: import_zod5.z.number().int().min(0),
+  startColumn: import_zod5.z.number().int().min(0),
+  endLine: import_zod5.z.number().int().min(0),
+  endColumn: import_zod5.z.number().int().min(0),
+  text: import_zod5.z.string()
+});
+var WorkspaceContextSchema = import_zod5.z.object({
+  rootPath: import_zod5.z.string(),
+  name: import_zod5.z.string().optional()
+});
+var ContextPayloadSchema = import_zod5.z.object({
   workspace: WorkspaceContextSchema.optional(),
   activeFile: ActiveFileContextSchema.optional(),
   selection: SelectionContextSchema.optional()
 });
 // src/protocol/host-events.ts
-var import_zod19 = require("zod");
+var import_zod7 = require("zod");
 
 // src/protocol/session.ts
-var import_zod18 = require("zod");
+var import_zod6 = require("zod");
 var SessionStatus = {
   IDLE: "idle",
   STARTING: "starting",
@@ -1175,7 +299,7 @@ var SessionStatus = {
   FAILED: "failed",
   RESUMING: "resuming"
 };
-var SessionStatusSchema = import_zod18.z.enum(SessionStatus);
+var SessionStatusSchema = import_zod6.z.enum(SessionStatus);
 var SessionTransitionEvent = {
   CREATE_SESSION: "create_session",
   CLI_SPAWNED: "cli_spawned",
@@ -1186,7 +310,7 @@ var SessionTransitionEvent = {
   RESUME: "resume",
   ERROR: "error"
 };
-var SessionTransitionEventSchema = import_zod18.z.enum(SessionTransitionEvent);
+var SessionTransitionEventSchema = import_zod6.z.enum(SessionTransitionEvent);
 var SESSION_TRANSITIONS = [
   {
     from: SessionStatus.IDLE,
@@ -1279,24 +403,24 @@ var TERMINAL_STATUSES = new Set([
   SessionStatus.CANCELED,
   SessionStatus.FAILED
 ]);
-var SessionMetadataSchema = import_zod18.z.object({
-  sessionId: import_zod18.z.string(),
+var SessionMetadataSchema = import_zod6.z.object({
+  sessionId: import_zod6.z.string(),
   status: SessionStatusSchema,
-  model: import_zod18.z.string().optional(),
-  createdAt: import_zod18.z.number(),
-  updatedAt: import_zod18.z.number(),
-  title: import_zod18.z.string().optional(),
-  prompt: import_zod18.z.string().optional()
-});
-var SessionSummarySchema = import_zod18.z.object({
-  sessionId: import_zod18.z.string(),
+  model: import_zod6.z.string().optional(),
+  createdAt: import_zod6.z.number(),
+  updatedAt: import_zod6.z.number(),
+  title: import_zod6.z.string().optional(),
+  prompt: import_zod6.z.string().optional()
+});
+var SessionSummarySchema = import_zod6.z.object({
+  sessionId: import_zod6.z.string(),
   status: SessionStatusSchema,
-  model: import_zod18.z.string().optional(),
-  title: import_zod18.z.string().optional(),
-  createdAt: import_zod18.z.number(),
-  updatedAt: import_zod18.z.number(),
-  messageCount: import_zod18.z.number(),
-  toolCount: import_zod18.z.number()
+  model: import_zod6.z.string().optional(),
+  title: import_zod6.z.string().optional(),
+  createdAt: import_zod6.z.number(),
+  updatedAt: import_zod6.z.number(),
+  messageCount: import_zod6.z.number(),
+  toolCount: import_zod6.z.number()
 });
 
 // src/protocol/host-events.ts
@@ -1310,7 +434,7 @@ var HostEventType = {
   SESSION_LIST: "session_list",
   SESSION_COMPLETED: "session_completed"
 };
-var HostEventTypeSchema = import_zod19.z.enum(HostEventType);
+var HostEventTypeSchema = import_zod7.z.enum(HostEventType);
 var TimelineEntryKind = {
   MESSAGE: "message",
   TOOL_CALL: "tool_call",
@@ -1318,86 +442,86 @@ var TimelineEntryKind = {
   ERROR: "error",
   DONE: "done"
 };
-var TimelineEntryKindSchema = import_zod19.z.enum(TimelineEntryKind);
-var TimelineEntrySchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
+var TimelineEntryKindSchema = import_zod7.z.enum(TimelineEntryKind);
+var TimelineEntrySchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
   kind: TimelineEntryKindSchema,
-  timestamp: import_zod19.z.number(),
-  data: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown())
+  timestamp: import_zod7.z.number(),
+  data: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown())
 });
-var SessionStateEventSchema = import_zod19.z.object({
+var SessionStateEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_STATE),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
+  type: import_zod7.z.literal(HostEventType.SESSION_STATE),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
     status: SessionStatusSchema,
     metadata: SessionMetadataSchema.optional(),
-    timeline: import_zod19.z.array(TimelineEntrySchema).optional()
+    timeline: import_zod7.z.array(TimelineEntrySchema).optional()
   })
 });
-var TextDeltaEventSchema = import_zod19.z.object({
+var TextDeltaEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TEXT_DELTA),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    content: import_zod19.z.string()
+  type: import_zod7.z.literal(HostEventType.TEXT_DELTA),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
+    content: import_zod7.z.string()
   })
 });
-var ToolStartedEventSchema = import_zod19.z.object({
+var ToolStartedEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TOOL_STARTED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    tool: import_zod19.z.string(),
-    toolId: import_zod19.z.string().optional(),
-    parameters: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional()
+  type: import_zod7.z.literal(HostEventType.TOOL_STARTED),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
+    tool: import_zod7.z.string(),
+    toolId: import_zod7.z.string().optional(),
+    parameters: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional()
   })
 });
-var ToolCompletedEventSchema = import_zod19.z.object({
+var ToolCompletedEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TOOL_COMPLETED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    tool: import_zod19.z.string(),
-    toolId: import_zod19.z.string().optional(),
-    result: import_zod19.z.unknown().optional(),
-    duration: import_zod19.z.number().optional(),
-    success: import_zod19.z.boolean(),
-    error: import_zod19.z.string().optional()
+  type: import_zod7.z.literal(HostEventType.TOOL_COMPLETED),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
+    tool: import_zod7.z.string(),
+    toolId: import_zod7.z.string().optional(),
+    result: import_zod7.z.unknown().optional(),
+    duration: import_zod7.z.number().optional(),
+    success: import_zod7.z.boolean(),
+    error: import_zod7.z.string().optional()
   })
 });
-var ThinkingEventSchema = import_zod19.z.object({
+var ThinkingEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.THINKING),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    content: import_zod19.z.string().optional()
+  type: import_zod7.z.literal(HostEventType.THINKING),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
+    content: import_zod7.z.string().optional()
   })
 });
-var ErrorEventSchema = import_zod19.z.object({
+var ErrorEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.ERROR),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string().optional(),
+  type: import_zod7.z.literal(HostEventType.ERROR),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string().optional(),
     error: ProtocolErrorSchema
   })
 });
-var SessionListEventSchema = import_zod19.z.object({
+var SessionListEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_LIST),
-  payload: import_zod19.z.object({
-    sessions: import_zod19.z.array(SessionSummarySchema)
+  type: import_zod7.z.literal(HostEventType.SESSION_LIST),
+  payload: import_zod7.z.object({
+    sessions: import_zod7.z.array(SessionSummarySchema)
   })
 });
-var SessionCompletedEventSchema = import_zod19.z.object({
+var SessionCompletedEventSchema = import_zod7.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_COMPLETED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    summary: import_zod19.z.string().optional()
+  type: import_zod7.z.literal(HostEventType.SESSION_COMPLETED),
+  payload: import_zod7.z.object({
+    sessionId: import_zod7.z.string(),
+    summary: import_zod7.z.string().optional()
   })
 });
-var HostEventSchema = import_zod19.z.discriminatedUnion("type", [
+var HostEventSchema = import_zod7.z.discriminatedUnion("type", [
   SessionStateEventSchema,
   TextDeltaEventSchema,
   ToolStartedEventSchema,
@@ -1416,7 +540,7 @@ function createHostEvent(type, payload) {
 }
 
 // src/protocol/ui-intents.ts
-var import_zod20 = require("zod");
+var import_zod8 = require("zod");
 var UIIntentType = {
   SUBMIT_PROMPT: "submit_prompt",
   STOP_SESSION: "stop_session",
@@ -1426,54 +550,54 @@ var UIIntentType = {
   CLEAR_SESSION: "clear_session",
   WEBVIEW_READY: "webview_ready"
 };
-var UIIntentTypeSchema = import_zod20.z.enum(UIIntentType);
-var SubmitPromptIntentSchema = import_zod20.z.object({
+var UIIntentTypeSchema = import_zod8.z.enum(UIIntentType);
+var SubmitPromptIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.SUBMIT_PROMPT),
-  payload: import_zod20.z.object({
-    text: import_zod20.z.string().min(1),
+  type: import_zod8.z.literal(UIIntentType.SUBMIT_PROMPT),
+  payload: import_zod8.z.object({
+    text: import_zod8.z.string().min(1),
     context: ContextPayloadSchema.optional()
   })
 });
-var StopSessionIntentSchema = import_zod20.z.object({
+var StopSessionIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.STOP_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod8.z.literal(UIIntentType.STOP_SESSION),
+  payload: import_zod8.z.object({
+    sessionId: import_zod8.z.string()
   })
 });
-var ResumeSessionIntentSchema = import_zod20.z.object({
+var ResumeSessionIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.RESUME_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod8.z.literal(UIIntentType.RESUME_SESSION),
+  payload: import_zod8.z.object({
+    sessionId: import_zod8.z.string()
   })
 });
-var RequestSessionsIntentSchema = import_zod20.z.object({
+var RequestSessionsIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSIONS),
-  payload: import_zod20.z.object({}).optional()
+  type: import_zod8.z.literal(UIIntentType.REQUEST_SESSIONS),
+  payload: import_zod8.z.object({}).optional()
 });
-var RequestSessionDetailIntentSchema = import_zod20.z.object({
+var RequestSessionDetailIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod8.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+  payload: import_zod8.z.object({
+    sessionId: import_zod8.z.string()
   })
 });
-var ClearSessionIntentSchema = import_zod20.z.object({
+var ClearSessionIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.CLEAR_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod8.z.literal(UIIntentType.CLEAR_SESSION),
+  payload: import_zod8.z.object({
+    sessionId: import_zod8.z.string()
   })
 });
-var WebviewReadyIntentSchema = import_zod20.z.object({
+var WebviewReadyIntentSchema = import_zod8.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.WEBVIEW_READY),
-  payload: import_zod20.z.object({}).optional()
+  type: import_zod8.z.literal(UIIntentType.WEBVIEW_READY),
+  payload: import_zod8.z.object({}).optional()
 });
-var UIIntentSchema = import_zod20.z.discriminatedUnion("type", [
+var UIIntentSchema = import_zod8.z.discriminatedUnion("type", [
   SubmitPromptIntentSchema,
   StopSessionIntentSchema,
   ResumeSessionIntentSchema,